fakecloud-iotwireless 0.41.0

// @generated by scripts/generate-iotwireless-tables.py (do not edit by hand)
// AWS IoT Wireless (iotwireless) 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: "AssociateAwsAccountWithPartnerAccount",
        method: "POST",
        segs: &[Seg::Fixed("partner-accounts")],
        verb: Verb::Action,
        rtype: "partner-accounts",
        nlabels: 0,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "ConflictException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "Sidewalk",
                src: Src::Body,
                req: true,
                kind: K::Struct,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "ClientRequestToken",
                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: "Tags",
                src: Src::Body,
                req: false,
                kind: K::List,
                min_len: Some(0),
                max_len: Some(200),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("Sidewalk", K::Struct), ("Arn", K::Str)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "AssociateMulticastGroupWithFuotaTask",
        method: "PUT",
        segs: &[
            Seg::Fixed("fuota-tasks"),
            Seg::Label("Id"),
            Seg::Fixed("multicast-group"),
        ],
        verb: Verb::Action,
        rtype: "fuota-tasks",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "ConflictException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "Id",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "MulticastGroupId",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "AssociateWirelessDeviceWithFuotaTask",
        method: "PUT",
        segs: &[
            Seg::Fixed("fuota-tasks"),
            Seg::Label("Id"),
            Seg::Fixed("wireless-device"),
        ],
        verb: Verb::Action,
        rtype: "fuota-tasks",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "ConflictException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "Id",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "WirelessDeviceId",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "AssociateWirelessDeviceWithMulticastGroup",
        method: "PUT",
        segs: &[
            Seg::Fixed("multicast-groups"),
            Seg::Label("Id"),
            Seg::Fixed("wireless-device"),
        ],
        verb: Verb::Action,
        rtype: "multicast-groups",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "ConflictException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "Id",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "WirelessDeviceId",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "AssociateWirelessDeviceWithThing",
        method: "PUT",
        segs: &[
            Seg::Fixed("wireless-devices"),
            Seg::Label("Id"),
            Seg::Fixed("thing"),
        ],
        verb: Verb::Action,
        rtype: "wireless-devices",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "ConflictException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "Id",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "ThingArn",
                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: "AssociateWirelessGatewayWithCertificate",
        method: "PUT",
        segs: &[
            Seg::Fixed("wireless-gateways"),
            Seg::Label("Id"),
            Seg::Fixed("certificate"),
        ],
        verb: Verb::Action,
        rtype: "wireless-gateways",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "ConflictException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "Id",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "IotCertificateId",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(4096),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("IotCertificateId", K::Str)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "AssociateWirelessGatewayWithThing",
        method: "PUT",
        segs: &[
            Seg::Fixed("wireless-gateways"),
            Seg::Label("Id"),
            Seg::Fixed("thing"),
        ],
        verb: Verb::Action,
        rtype: "wireless-gateways",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "ConflictException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "Id",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "ThingArn",
                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: "CancelMulticastGroupSession",
        method: "DELETE",
        segs: &[
            Seg::Fixed("multicast-groups"),
            Seg::Label("Id"),
            Seg::Fixed("session"),
        ],
        verb: Verb::Action,
        rtype: "multicast-groups",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "ConflictException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[Rule {
            wire: "Id",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(0),
            max_len: Some(256),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "CreateDestination",
        method: "POST",
        segs: &[Seg::Fixed("destinations")],
        verb: Verb::Create,
        rtype: "destinations",
        nlabels: 0,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "ConflictException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "Name",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "ExpressionType",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["RuleName", "MqttTopic"],
            },
            Rule {
                wire: "Expression",
                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: "Description",
                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: "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: "Tags",
                src: Src::Body,
                req: false,
                kind: K::List,
                min_len: Some(0),
                max_len: Some(200),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "ClientRequestToken",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(64),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("Arn", K::Str), ("Name", K::Str)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "CreateDeviceProfile",
        method: "POST",
        segs: &[Seg::Fixed("device-profiles")],
        verb: Verb::Create,
        rtype: "device-profiles",
        nlabels: 0,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "ConflictException",
            "InternalServerException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "Name",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "Tags",
                src: Src::Body,
                req: false,
                kind: K::List,
                min_len: Some(0),
                max_len: Some(200),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "ClientRequestToken",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(64),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("Arn", K::Str), ("Id", K::Str)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "CreateFuotaTask",
        method: "POST",
        segs: &[Seg::Fixed("fuota-tasks")],
        verb: Verb::Create,
        rtype: "fuota-tasks",
        nlabels: 0,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "ConflictException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "Name",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                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(2048),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "ClientRequestToken",
                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: "FirmwareUpdateImage",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(4096),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "FirmwareUpdateRole",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(2048),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "Tags",
                src: Src::Body,
                req: false,
                kind: K::List,
                min_len: Some(0),
                max_len: Some(200),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "RedundancyPercent",
                src: Src::Body,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(0),
                max_val: Some(100),
                enums: &[],
            },
            Rule {
                wire: "FragmentSizeBytes",
                src: Src::Body,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "FragmentIntervalMS",
                src: Src::Body,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "Descriptor",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(332),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("Arn", K::Str), ("Id", K::Str)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "CreateMulticastGroup",
        method: "POST",
        segs: &[Seg::Fixed("multicast-groups")],
        verb: Verb::Create,
        rtype: "multicast-groups",
        nlabels: 0,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "ConflictException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "Name",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                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(2048),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "ClientRequestToken",
                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: "LoRaWAN",
                src: Src::Body,
                req: true,
                kind: K::Struct,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "Tags",
                src: Src::Body,
                req: false,
                kind: K::List,
                min_len: Some(0),
                max_len: Some(200),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("Arn", K::Str), ("Id", K::Str)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "CreateNetworkAnalyzerConfiguration",
        method: "POST",
        segs: &[Seg::Fixed("network-analyzer-configurations")],
        verb: Verb::Create,
        rtype: "network-analyzer-configurations",
        nlabels: 0,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "ConflictException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "Name",
                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: "WirelessDevices",
                src: Src::Body,
                req: false,
                kind: K::List,
                min_len: Some(0),
                max_len: Some(250),
                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(2048),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "Tags",
                src: Src::Body,
                req: false,
                kind: K::List,
                min_len: Some(0),
                max_len: Some(200),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "ClientRequestToken",
                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: "MulticastGroups",
                src: Src::Body,
                req: false,
                kind: K::List,
                min_len: Some(0),
                max_len: Some(10),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("Arn", K::Str), ("Name", K::Str)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "CreateServiceProfile",
        method: "POST",
        segs: &[Seg::Fixed("service-profiles")],
        verb: Verb::Create,
        rtype: "service-profiles",
        nlabels: 0,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "ConflictException",
            "InternalServerException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "Name",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "Tags",
                src: Src::Body,
                req: false,
                kind: K::List,
                min_len: Some(0),
                max_len: Some(200),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "ClientRequestToken",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(64),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("Arn", K::Str), ("Id", K::Str)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "CreateWirelessDevice",
        method: "POST",
        segs: &[Seg::Fixed("wireless-devices")],
        verb: Verb::Create,
        rtype: "wireless-devices",
        nlabels: 0,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "ConflictException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "Type",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["Sidewalk", "LoRaWAN"],
            },
            Rule {
                wire: "Name",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                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(2048),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "DestinationName",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "ClientRequestToken",
                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: "Tags",
                src: Src::Body,
                req: false,
                kind: K::List,
                min_len: Some(0),
                max_len: Some(200),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "Positioning",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["Enabled", "Disabled"],
            },
        ],
        omembers: &[("Arn", K::Str), ("Id", K::Str)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "CreateWirelessGateway",
        method: "POST",
        segs: &[Seg::Fixed("wireless-gateways")],
        verb: Verb::Create,
        rtype: "wireless-gateways",
        nlabels: 0,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "ConflictException",
            "InternalServerException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "Name",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                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(2048),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "LoRaWAN",
                src: Src::Body,
                req: true,
                kind: K::Struct,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "Tags",
                src: Src::Body,
                req: false,
                kind: K::List,
                min_len: Some(0),
                max_len: Some(200),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "ClientRequestToken",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(64),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("Arn", K::Str), ("Id", K::Str)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "CreateWirelessGatewayTask",
        method: "POST",
        segs: &[
            Seg::Fixed("wireless-gateways"),
            Seg::Label("Id"),
            Seg::Fixed("tasks"),
        ],
        verb: Verb::Action,
        rtype: "wireless-gateways",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "ConflictException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "Id",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "WirelessGatewayTaskDefinitionId",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(36),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[
            ("WirelessGatewayTaskDefinitionId", K::Str),
            ("Status", K::Str),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "CreateWirelessGatewayTaskDefinition",
        method: "POST",
        segs: &[Seg::Fixed("wireless-gateway-task-definitions")],
        verb: Verb::Create,
        rtype: "wireless-gateway-task-definitions",
        nlabels: 0,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "ConflictException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "AutoCreateTasks",
                src: Src::Body,
                req: true,
                kind: K::Bool,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "Name",
                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: "ClientRequestToken",
                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: "Tags",
                src: Src::Body,
                req: false,
                kind: K::List,
                min_len: Some(0),
                max_len: Some(200),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("Id", K::Str), ("Arn", K::Str)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DeleteDestination",
        method: "DELETE",
        segs: &[Seg::Fixed("destinations"), Seg::Label("Name")],
        verb: Verb::Delete,
        rtype: "destinations",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "ConflictException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[Rule {
            wire: "Name",
            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: "DeleteDeviceProfile",
        method: "DELETE",
        segs: &[Seg::Fixed("device-profiles"), Seg::Label("Id")],
        verb: Verb::Delete,
        rtype: "device-profiles",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "ConflictException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[Rule {
            wire: "Id",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(0),
            max_len: Some(256),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DeleteFuotaTask",
        method: "DELETE",
        segs: &[Seg::Fixed("fuota-tasks"), Seg::Label("Id")],
        verb: Verb::Delete,
        rtype: "fuota-tasks",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[Rule {
            wire: "Id",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(0),
            max_len: Some(256),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DeleteMulticastGroup",
        method: "DELETE",
        segs: &[Seg::Fixed("multicast-groups"), Seg::Label("Id")],
        verb: Verb::Delete,
        rtype: "multicast-groups",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "ConflictException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[Rule {
            wire: "Id",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(0),
            max_len: Some(256),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DeleteNetworkAnalyzerConfiguration",
        method: "DELETE",
        segs: &[
            Seg::Fixed("network-analyzer-configurations"),
            Seg::Label("ConfigurationName"),
        ],
        verb: Verb::Delete,
        rtype: "network-analyzer-configurations",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "ConflictException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[Rule {
            wire: "ConfigurationName",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(1024),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DeleteQueuedMessages",
        method: "DELETE",
        segs: &[
            Seg::Fixed("wireless-devices"),
            Seg::Label("Id"),
            Seg::Fixed("data"),
        ],
        verb: Verb::Action,
        rtype: "wireless-devices",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "Id",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "messageId",
                src: Src::Query,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "WirelessDeviceType",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["Sidewalk", "LoRaWAN"],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DeleteServiceProfile",
        method: "DELETE",
        segs: &[Seg::Fixed("service-profiles"), Seg::Label("Id")],
        verb: Verb::Delete,
        rtype: "service-profiles",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "ConflictException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[Rule {
            wire: "Id",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(0),
            max_len: Some(256),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DeleteWirelessDevice",
        method: "DELETE",
        segs: &[Seg::Fixed("wireless-devices"), Seg::Label("Id")],
        verb: Verb::Delete,
        rtype: "wireless-devices",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[Rule {
            wire: "Id",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(0),
            max_len: Some(256),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DeleteWirelessDeviceImportTask",
        method: "DELETE",
        segs: &[Seg::Fixed("wireless_device_import_task"), Seg::Label("Id")],
        verb: Verb::Delete,
        rtype: "wireless_device_import_task",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "ConflictException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[Rule {
            wire: "Id",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(0),
            max_len: Some(256),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DeleteWirelessGateway",
        method: "DELETE",
        segs: &[Seg::Fixed("wireless-gateways"), Seg::Label("Id")],
        verb: Verb::Delete,
        rtype: "wireless-gateways",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[Rule {
            wire: "Id",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(0),
            max_len: Some(256),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DeleteWirelessGatewayTask",
        method: "DELETE",
        segs: &[
            Seg::Fixed("wireless-gateways"),
            Seg::Label("Id"),
            Seg::Fixed("tasks"),
        ],
        verb: Verb::Action,
        rtype: "wireless-gateways",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[Rule {
            wire: "Id",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(0),
            max_len: Some(256),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DeleteWirelessGatewayTaskDefinition",
        method: "DELETE",
        segs: &[
            Seg::Fixed("wireless-gateway-task-definitions"),
            Seg::Label("Id"),
        ],
        verb: Verb::Delete,
        rtype: "wireless-gateway-task-definitions",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[Rule {
            wire: "Id",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(0),
            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: "DeregisterWirelessDevice",
        method: "PATCH",
        segs: &[
            Seg::Fixed("wireless-devices"),
            Seg::Label("Identifier"),
            Seg::Fixed("deregister"),
        ],
        verb: Verb::Action,
        rtype: "wireless-devices",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "Identifier",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "WirelessDeviceType",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["Sidewalk", "LoRaWAN"],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DisassociateAwsAccountFromPartnerAccount",
        method: "DELETE",
        segs: &[
            Seg::Fixed("partner-accounts"),
            Seg::Label("PartnerAccountId"),
        ],
        verb: Verb::Action,
        rtype: "partner-accounts",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "PartnerAccountId",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "partnerType",
                src: Src::Query,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["Sidewalk"],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DisassociateMulticastGroupFromFuotaTask",
        method: "DELETE",
        segs: &[
            Seg::Fixed("fuota-tasks"),
            Seg::Label("Id"),
            Seg::Fixed("multicast-groups"),
            Seg::Label("MulticastGroupId"),
        ],
        verb: Verb::Action,
        rtype: "fuota-tasks",
        nlabels: 2,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "ConflictException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "Id",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "MulticastGroupId",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DisassociateWirelessDeviceFromFuotaTask",
        method: "DELETE",
        segs: &[
            Seg::Fixed("fuota-tasks"),
            Seg::Label("Id"),
            Seg::Fixed("wireless-devices"),
            Seg::Label("WirelessDeviceId"),
        ],
        verb: Verb::Action,
        rtype: "fuota-tasks",
        nlabels: 2,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "ConflictException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "Id",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "WirelessDeviceId",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DisassociateWirelessDeviceFromMulticastGroup",
        method: "DELETE",
        segs: &[
            Seg::Fixed("multicast-groups"),
            Seg::Label("Id"),
            Seg::Fixed("wireless-devices"),
            Seg::Label("WirelessDeviceId"),
        ],
        verb: Verb::Action,
        rtype: "multicast-groups",
        nlabels: 2,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "Id",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "WirelessDeviceId",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DisassociateWirelessDeviceFromThing",
        method: "DELETE",
        segs: &[
            Seg::Fixed("wireless-devices"),
            Seg::Label("Id"),
            Seg::Fixed("thing"),
        ],
        verb: Verb::Action,
        rtype: "wireless-devices",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "ConflictException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[Rule {
            wire: "Id",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(0),
            max_len: Some(256),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DisassociateWirelessGatewayFromCertificate",
        method: "DELETE",
        segs: &[
            Seg::Fixed("wireless-gateways"),
            Seg::Label("Id"),
            Seg::Fixed("certificate"),
        ],
        verb: Verb::Action,
        rtype: "wireless-gateways",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[Rule {
            wire: "Id",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(0),
            max_len: Some(256),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "DisassociateWirelessGatewayFromThing",
        method: "DELETE",
        segs: &[
            Seg::Fixed("wireless-gateways"),
            Seg::Label("Id"),
            Seg::Fixed("thing"),
        ],
        verb: Verb::Action,
        rtype: "wireless-gateways",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "ConflictException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[Rule {
            wire: "Id",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(0),
            max_len: Some(256),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "GetDestination",
        method: "GET",
        segs: &[Seg::Fixed("destinations"), Seg::Label("Name")],
        verb: Verb::Get,
        rtype: "destinations",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[Rule {
            wire: "Name",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(0),
            max_len: Some(128),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[
            ("Arn", K::Str),
            ("Name", K::Str),
            ("Expression", K::Str),
            ("ExpressionType", K::Str),
            ("Description", K::Str),
            ("RoleArn", K::Str),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "GetDeviceProfile",
        method: "GET",
        segs: &[Seg::Fixed("device-profiles"), Seg::Label("Id")],
        verb: Verb::Get,
        rtype: "device-profiles",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[Rule {
            wire: "Id",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(0),
            max_len: Some(256),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[
            ("Arn", K::Str),
            ("Name", K::Str),
            ("Id", K::Str),
            ("LoRaWAN", K::Struct),
            ("Sidewalk", K::Struct),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "GetEventConfigurationByResourceTypes",
        method: "GET",
        segs: &[Seg::Fixed("event-configurations-resource-types")],
        verb: Verb::Action,
        rtype: "event-configurations-resource-types",
        nlabels: 0,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ThrottlingException",
        ],
        rules: &[],
        omembers: &[
            ("DeviceRegistrationState", K::Struct),
            ("Proximity", K::Struct),
            ("Join", K::Struct),
            ("ConnectionStatus", K::Struct),
            ("MessageDeliveryStatus", K::Struct),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "GetFuotaTask",
        method: "GET",
        segs: &[Seg::Fixed("fuota-tasks"), Seg::Label("Id")],
        verb: Verb::Get,
        rtype: "fuota-tasks",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[Rule {
            wire: "Id",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(0),
            max_len: Some(256),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[
            ("Arn", K::Str),
            ("Id", K::Str),
            ("Status", K::Str),
            ("Name", K::Str),
            ("Description", K::Str),
            ("LoRaWAN", K::Struct),
            ("FirmwareUpdateImage", K::Str),
            ("FirmwareUpdateRole", K::Str),
            ("CreatedAt", K::Ts),
            ("RedundancyPercent", K::Int),
            ("FragmentSizeBytes", K::Int),
            ("FragmentIntervalMS", K::Int),
            ("Descriptor", K::Str),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "GetLogLevelsByResourceTypes",
        method: "GET",
        segs: &[Seg::Fixed("log-levels")],
        verb: Verb::Action,
        rtype: "log-levels",
        nlabels: 0,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[],
        omembers: &[
            ("DefaultLogLevel", K::Str),
            ("WirelessGatewayLogOptions", K::List),
            ("WirelessDeviceLogOptions", K::List),
            ("FuotaTaskLogOptions", K::List),
        ],
        list_field: Some("WirelessGatewayLogOptions"),
        list_elems: &[("Type", K::Str), ("LogLevel", K::Str), ("Events", K::List)],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "GetMetricConfiguration",
        method: "GET",
        segs: &[Seg::Fixed("metric-configuration")],
        verb: Verb::Action,
        rtype: "metric-configuration",
        nlabels: 0,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "ConflictException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[],
        omembers: &[("SummaryMetric", K::Struct)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "GetMetrics",
        method: "POST",
        segs: &[Seg::Fixed("metrics")],
        verb: Verb::Action,
        rtype: "metrics",
        nlabels: 0,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "ConflictException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[],
        omembers: &[("SummaryMetricQueryResults", K::List)],
        list_field: Some("SummaryMetricQueryResults"),
        list_elems: &[
            ("QueryId", K::Str),
            ("QueryStatus", K::Str),
            ("Error", K::Str),
            ("MetricName", K::Str),
            ("Dimensions", K::List),
            ("AggregationPeriod", K::Str),
            ("StartTimestamp", K::Ts),
            ("EndTimestamp", K::Ts),
            ("Timestamps", K::List),
            ("Values", K::List),
            ("Unit", K::Str),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "GetMulticastGroup",
        method: "GET",
        segs: &[Seg::Fixed("multicast-groups"), Seg::Label("Id")],
        verb: Verb::Get,
        rtype: "multicast-groups",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[Rule {
            wire: "Id",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(0),
            max_len: Some(256),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[
            ("Arn", K::Str),
            ("Id", K::Str),
            ("Name", K::Str),
            ("Description", K::Str),
            ("Status", K::Str),
            ("LoRaWAN", K::Struct),
            ("CreatedAt", K::Ts),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "GetMulticastGroupSession",
        method: "GET",
        segs: &[
            Seg::Fixed("multicast-groups"),
            Seg::Label("Id"),
            Seg::Fixed("session"),
        ],
        verb: Verb::Action,
        rtype: "multicast-groups",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[Rule {
            wire: "Id",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(0),
            max_len: Some(256),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[("LoRaWAN", K::Struct)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "GetNetworkAnalyzerConfiguration",
        method: "GET",
        segs: &[
            Seg::Fixed("network-analyzer-configurations"),
            Seg::Label("ConfigurationName"),
        ],
        verb: Verb::Get,
        rtype: "network-analyzer-configurations",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[Rule {
            wire: "ConfigurationName",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(1024),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[
            ("TraceContent", K::Struct),
            ("WirelessDevices", K::List),
            ("WirelessGateways", K::List),
            ("Description", K::Str),
            ("Arn", K::Str),
            ("Name", K::Str),
            ("MulticastGroups", K::List),
        ],
        list_field: Some("WirelessDevices"),
        list_elems: &[],
        list_scalar: true,
        req_payload: false,
    },
    OpMeta {
        op: "GetPartnerAccount",
        method: "GET",
        segs: &[
            Seg::Fixed("partner-accounts"),
            Seg::Label("PartnerAccountId"),
        ],
        verb: Verb::Get,
        rtype: "partner-accounts",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "PartnerAccountId",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "partnerType",
                src: Src::Query,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["Sidewalk"],
            },
        ],
        omembers: &[("Sidewalk", K::Struct), ("AccountLinked", K::Bool)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "GetPosition",
        method: "GET",
        segs: &[Seg::Fixed("positions"), Seg::Label("ResourceIdentifier")],
        verb: Verb::Get,
        rtype: "positions",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "ResourceIdentifier",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "resourceType",
                src: Src::Query,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["WirelessDevice", "WirelessGateway"],
            },
        ],
        omembers: &[
            ("Position", K::List),
            ("Accuracy", K::Struct),
            ("SolverType", K::Str),
            ("SolverProvider", K::Str),
            ("SolverVersion", K::Str),
            ("Timestamp", K::Str),
        ],
        list_field: Some("Position"),
        list_elems: &[],
        list_scalar: true,
        req_payload: false,
    },
    OpMeta {
        op: "GetPositionConfiguration",
        method: "GET",
        segs: &[
            Seg::Fixed("position-configurations"),
            Seg::Label("ResourceIdentifier"),
        ],
        verb: Verb::Get,
        rtype: "position-configurations",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "ResourceIdentifier",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "resourceType",
                src: Src::Query,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["WirelessDevice", "WirelessGateway"],
            },
        ],
        omembers: &[("Solvers", K::Struct), ("Destination", K::Str)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "GetPositionEstimate",
        method: "POST",
        segs: &[Seg::Fixed("position-estimate")],
        verb: Verb::Action,
        rtype: "position-estimate",
        nlabels: 0,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[],
        omembers: &[("GeoJsonPayload", K::Blob)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "GetResourceEventConfiguration",
        method: "GET",
        segs: &[Seg::Fixed("event-configurations"), Seg::Label("Identifier")],
        verb: Verb::Get,
        rtype: "event-configurations",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "Identifier",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "identifierType",
                src: Src::Query,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[
                    "PartnerAccountId",
                    "DevEui",
                    "GatewayEui",
                    "WirelessDeviceId",
                    "WirelessGatewayId",
                ],
            },
            Rule {
                wire: "partnerType",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["Sidewalk"],
            },
        ],
        omembers: &[
            ("DeviceRegistrationState", K::Struct),
            ("Proximity", K::Struct),
            ("Join", K::Struct),
            ("ConnectionStatus", K::Struct),
            ("MessageDeliveryStatus", K::Struct),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "GetResourceLogLevel",
        method: "GET",
        segs: &[Seg::Fixed("log-levels"), Seg::Label("ResourceIdentifier")],
        verb: Verb::Get,
        rtype: "log-levels",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "ResourceIdentifier",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "resourceType",
                src: Src::Query,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("LogLevel", K::Str)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "GetResourcePosition",
        method: "GET",
        segs: &[
            Seg::Fixed("resource-positions"),
            Seg::Label("ResourceIdentifier"),
        ],
        verb: Verb::Get,
        rtype: "resource-positions",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "ResourceIdentifier",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "resourceType",
                src: Src::Query,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["WirelessDevice", "WirelessGateway"],
            },
        ],
        omembers: &[("GeoJsonPayload", K::Blob)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "GetServiceEndpoint",
        method: "GET",
        segs: &[Seg::Fixed("service-endpoint")],
        verb: Verb::Action,
        rtype: "service-endpoint",
        nlabels: 0,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[Rule {
            wire: "serviceType",
            src: Src::Query,
            req: false,
            kind: K::Str,
            min_len: None,
            max_len: None,
            min_val: None,
            max_val: None,
            enums: &["CUPS", "LNS"],
        }],
        omembers: &[
            ("ServiceType", K::Str),
            ("ServiceEndpoint", K::Str),
            ("ServerTrust", K::Str),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "GetServiceProfile",
        method: "GET",
        segs: &[Seg::Fixed("service-profiles"), Seg::Label("Id")],
        verb: Verb::Get,
        rtype: "service-profiles",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[Rule {
            wire: "Id",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(0),
            max_len: Some(256),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[
            ("Arn", K::Str),
            ("Name", K::Str),
            ("Id", K::Str),
            ("LoRaWAN", K::Struct),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "GetWirelessDevice",
        method: "GET",
        segs: &[Seg::Fixed("wireless-devices"), Seg::Label("Identifier")],
        verb: Verb::Get,
        rtype: "wireless-devices",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "Identifier",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "identifierType",
                src: Src::Query,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[
                    "WirelessDeviceId",
                    "DevEui",
                    "ThingName",
                    "SidewalkManufacturingSn",
                ],
            },
        ],
        omembers: &[
            ("Type", K::Str),
            ("Name", K::Str),
            ("Description", K::Str),
            ("DestinationName", K::Str),
            ("Id", K::Str),
            ("Arn", K::Str),
            ("ThingName", K::Str),
            ("ThingArn", K::Str),
            ("LoRaWAN", K::Struct),
            ("Sidewalk", K::Struct),
            ("Positioning", K::Str),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "GetWirelessDeviceImportTask",
        method: "GET",
        segs: &[Seg::Fixed("wireless_device_import_task"), Seg::Label("Id")],
        verb: Verb::Get,
        rtype: "wireless_device_import_task",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "ConflictException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[Rule {
            wire: "Id",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(0),
            max_len: Some(256),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[
            ("Id", K::Str),
            ("Arn", K::Str),
            ("DestinationName", K::Str),
            ("Positioning", K::Str),
            ("Sidewalk", K::Struct),
            ("CreationTime", K::Ts),
            ("Status", K::Str),
            ("StatusReason", K::Str),
            ("InitializedImportedDeviceCount", K::Int),
            ("PendingImportedDeviceCount", K::Int),
            ("OnboardedImportedDeviceCount", K::Int),
            ("FailedImportedDeviceCount", K::Int),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "GetWirelessDeviceStatistics",
        method: "GET",
        segs: &[
            Seg::Fixed("wireless-devices"),
            Seg::Label("WirelessDeviceId"),
            Seg::Fixed("statistics"),
        ],
        verb: Verb::Action,
        rtype: "wireless-devices",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[Rule {
            wire: "WirelessDeviceId",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(0),
            max_len: Some(256),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[
            ("WirelessDeviceId", K::Str),
            ("LastUplinkReceivedAt", K::Str),
            ("LoRaWAN", K::Struct),
            ("Sidewalk", K::Struct),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "GetWirelessGateway",
        method: "GET",
        segs: &[Seg::Fixed("wireless-gateways"), Seg::Label("Identifier")],
        verb: Verb::Get,
        rtype: "wireless-gateways",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "Identifier",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "identifierType",
                src: Src::Query,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["GatewayEui", "WirelessGatewayId", "ThingName"],
            },
        ],
        omembers: &[
            ("Name", K::Str),
            ("Id", K::Str),
            ("Description", K::Str),
            ("LoRaWAN", K::Struct),
            ("Arn", K::Str),
            ("ThingName", K::Str),
            ("ThingArn", K::Str),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "GetWirelessGatewayCertificate",
        method: "GET",
        segs: &[
            Seg::Fixed("wireless-gateways"),
            Seg::Label("Id"),
            Seg::Fixed("certificate"),
        ],
        verb: Verb::Action,
        rtype: "wireless-gateways",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[Rule {
            wire: "Id",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(0),
            max_len: Some(256),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[
            ("IotCertificateId", K::Str),
            ("LoRaWANNetworkServerCertificateId", K::Str),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "GetWirelessGatewayFirmwareInformation",
        method: "GET",
        segs: &[
            Seg::Fixed("wireless-gateways"),
            Seg::Label("Id"),
            Seg::Fixed("firmware-information"),
        ],
        verb: Verb::Action,
        rtype: "wireless-gateways",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[Rule {
            wire: "Id",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(0),
            max_len: Some(256),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[("LoRaWAN", K::Struct)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "GetWirelessGatewayStatistics",
        method: "GET",
        segs: &[
            Seg::Fixed("wireless-gateways"),
            Seg::Label("WirelessGatewayId"),
            Seg::Fixed("statistics"),
        ],
        verb: Verb::Action,
        rtype: "wireless-gateways",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[Rule {
            wire: "WirelessGatewayId",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(0),
            max_len: Some(256),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[
            ("WirelessGatewayId", K::Str),
            ("LastUplinkReceivedAt", K::Str),
            ("ConnectionStatus", K::Str),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "GetWirelessGatewayTask",
        method: "GET",
        segs: &[
            Seg::Fixed("wireless-gateways"),
            Seg::Label("Id"),
            Seg::Fixed("tasks"),
        ],
        verb: Verb::Action,
        rtype: "wireless-gateways",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[Rule {
            wire: "Id",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(0),
            max_len: Some(256),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[
            ("WirelessGatewayId", K::Str),
            ("WirelessGatewayTaskDefinitionId", K::Str),
            ("LastUplinkReceivedAt", K::Str),
            ("TaskCreatedAt", K::Str),
            ("Status", K::Str),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "GetWirelessGatewayTaskDefinition",
        method: "GET",
        segs: &[
            Seg::Fixed("wireless-gateway-task-definitions"),
            Seg::Label("Id"),
        ],
        verb: Verb::Get,
        rtype: "wireless-gateway-task-definitions",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[Rule {
            wire: "Id",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(0),
            max_len: Some(36),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[
            ("AutoCreateTasks", K::Bool),
            ("Name", K::Str),
            ("Update", K::Struct),
            ("Arn", K::Str),
        ],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListDestinations",
        method: "GET",
        segs: &[Seg::Fixed("destinations")],
        verb: Verb::List,
        rtype: "destinations",
        nlabels: 0,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "maxResults",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(0),
                max_val: Some(250),
                enums: &[],
            },
            Rule {
                wire: "nextToken",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(4096),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("NextToken", K::Str), ("DestinationList", K::List)],
        list_field: Some("DestinationList"),
        list_elems: &[
            ("Arn", K::Str),
            ("Name", K::Str),
            ("ExpressionType", K::Str),
            ("Expression", K::Str),
            ("Description", K::Str),
            ("RoleArn", K::Str),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListDeviceProfiles",
        method: "GET",
        segs: &[Seg::Fixed("device-profiles")],
        verb: Verb::List,
        rtype: "device-profiles",
        nlabels: 0,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "nextToken",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(4096),
                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(0),
                max_val: Some(250),
                enums: &[],
            },
            Rule {
                wire: "deviceProfileType",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["Sidewalk", "LoRaWAN"],
            },
        ],
        omembers: &[("NextToken", K::Str), ("DeviceProfileList", K::List)],
        list_field: Some("DeviceProfileList"),
        list_elems: &[("Arn", K::Str), ("Name", K::Str), ("Id", K::Str)],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListDevicesForWirelessDeviceImportTask",
        method: "GET",
        segs: &[Seg::Fixed("wireless_device_import_task")],
        verb: Verb::List,
        rtype: "wireless_device_import_task",
        nlabels: 0,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "ConflictException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "id",
                src: Src::Query,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                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(0),
                max_val: Some(250),
                enums: &[],
            },
            Rule {
                wire: "nextToken",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(4096),
                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: &["INITIALIZED", "PENDING", "ONBOARDED", "FAILED"],
            },
        ],
        omembers: &[
            ("NextToken", K::Str),
            ("DestinationName", K::Str),
            ("Positioning", K::Str),
            ("Sidewalk", K::Struct),
            ("ImportedWirelessDeviceList", K::List),
        ],
        list_field: Some("ImportedWirelessDeviceList"),
        list_elems: &[("Sidewalk", K::Struct)],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListEventConfigurations",
        method: "GET",
        segs: &[Seg::Fixed("event-configurations")],
        verb: Verb::List,
        rtype: "event-configurations",
        nlabels: 0,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "resourceType",
                src: Src::Query,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["SidewalkAccount", "WirelessDevice", "WirelessGateway"],
            },
            Rule {
                wire: "maxResults",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(0),
                max_val: Some(250),
                enums: &[],
            },
            Rule {
                wire: "nextToken",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(4096),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("NextToken", K::Str), ("EventConfigurationsList", K::List)],
        list_field: Some("EventConfigurationsList"),
        list_elems: &[
            ("Identifier", K::Str),
            ("IdentifierType", K::Str),
            ("PartnerType", K::Str),
            ("Events", K::Struct),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListFuotaTasks",
        method: "GET",
        segs: &[Seg::Fixed("fuota-tasks")],
        verb: Verb::List,
        rtype: "fuota-tasks",
        nlabels: 0,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "nextToken",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(4096),
                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(0),
                max_val: Some(250),
                enums: &[],
            },
        ],
        omembers: &[("NextToken", K::Str), ("FuotaTaskList", K::List)],
        list_field: Some("FuotaTaskList"),
        list_elems: &[("Id", K::Str), ("Arn", K::Str), ("Name", K::Str)],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListMulticastGroups",
        method: "GET",
        segs: &[Seg::Fixed("multicast-groups")],
        verb: Verb::List,
        rtype: "multicast-groups",
        nlabels: 0,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "nextToken",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(4096),
                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(0),
                max_val: Some(250),
                enums: &[],
            },
        ],
        omembers: &[("NextToken", K::Str), ("MulticastGroupList", K::List)],
        list_field: Some("MulticastGroupList"),
        list_elems: &[("Id", K::Str), ("Arn", K::Str), ("Name", K::Str)],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListMulticastGroupsByFuotaTask",
        method: "GET",
        segs: &[
            Seg::Fixed("fuota-tasks"),
            Seg::Label("Id"),
            Seg::Fixed("multicast-groups"),
        ],
        verb: Verb::List,
        rtype: "fuota-tasks",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "Id",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "nextToken",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(4096),
                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(0),
                max_val: Some(250),
                enums: &[],
            },
        ],
        omembers: &[("NextToken", K::Str), ("MulticastGroupList", K::List)],
        list_field: Some("MulticastGroupList"),
        list_elems: &[("Id", K::Str)],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListNetworkAnalyzerConfigurations",
        method: "GET",
        segs: &[Seg::Fixed("network-analyzer-configurations")],
        verb: Verb::List,
        rtype: "network-analyzer-configurations",
        nlabels: 0,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "maxResults",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(0),
                max_val: Some(250),
                enums: &[],
            },
            Rule {
                wire: "nextToken",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(4096),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[
            ("NextToken", K::Str),
            ("NetworkAnalyzerConfigurationList", K::List),
        ],
        list_field: Some("NetworkAnalyzerConfigurationList"),
        list_elems: &[("Arn", K::Str), ("Name", K::Str)],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListPartnerAccounts",
        method: "GET",
        segs: &[Seg::Fixed("partner-accounts")],
        verb: Verb::List,
        rtype: "partner-accounts",
        nlabels: 0,
        has_input: true,
        errors: &[
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "nextToken",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(4096),
                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(0),
                max_val: Some(250),
                enums: &[],
            },
        ],
        omembers: &[("NextToken", K::Str), ("Sidewalk", K::List)],
        list_field: Some("Sidewalk"),
        list_elems: &[
            ("AmazonId", K::Str),
            ("Fingerprint", K::Str),
            ("Arn", K::Str),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListPositionConfigurations",
        method: "GET",
        segs: &[Seg::Fixed("position-configurations")],
        verb: Verb::List,
        rtype: "position-configurations",
        nlabels: 0,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "resourceType",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["WirelessDevice", "WirelessGateway"],
            },
            Rule {
                wire: "maxResults",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(0),
                max_val: Some(250),
                enums: &[],
            },
            Rule {
                wire: "nextToken",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(4096),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[
            ("PositionConfigurationList", K::List),
            ("NextToken", K::Str),
        ],
        list_field: Some("PositionConfigurationList"),
        list_elems: &[
            ("ResourceIdentifier", K::Str),
            ("ResourceType", K::Str),
            ("Solvers", K::Struct),
            ("Destination", K::Str),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListQueuedMessages",
        method: "GET",
        segs: &[
            Seg::Fixed("wireless-devices"),
            Seg::Label("Id"),
            Seg::Fixed("data"),
        ],
        verb: Verb::List,
        rtype: "wireless-devices",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "Id",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "nextToken",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(4096),
                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(0),
                max_val: Some(250),
                enums: &[],
            },
            Rule {
                wire: "WirelessDeviceType",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["Sidewalk", "LoRaWAN"],
            },
        ],
        omembers: &[
            ("NextToken", K::Str),
            ("DownlinkQueueMessagesList", K::List),
        ],
        list_field: Some("DownlinkQueueMessagesList"),
        list_elems: &[
            ("MessageId", K::Str),
            ("TransmitMode", K::Int),
            ("ReceivedAt", K::Str),
            ("LoRaWAN", K::Struct),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListServiceProfiles",
        method: "GET",
        segs: &[Seg::Fixed("service-profiles")],
        verb: Verb::List,
        rtype: "service-profiles",
        nlabels: 0,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "nextToken",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(4096),
                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(0),
                max_val: Some(250),
                enums: &[],
            },
        ],
        omembers: &[("NextToken", K::Str), ("ServiceProfileList", K::List)],
        list_field: Some("ServiceProfileList"),
        list_elems: &[("Arn", K::Str), ("Name", K::Str), ("Id", 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: &[
            "ConflictException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[Rule {
            wire: "resourceArn",
            src: Src::Query,
            req: true,
            kind: K::Str,
            min_len: Some(1),
            max_len: Some(1011),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[("Tags", K::List)],
        list_field: Some("Tags"),
        list_elems: &[("Key", K::Str), ("Value", K::Str)],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListWirelessDeviceImportTasks",
        method: "GET",
        segs: &[Seg::Fixed("wireless_device_import_tasks")],
        verb: Verb::List,
        rtype: "wireless_device_import_tasks",
        nlabels: 0,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "ConflictException",
            "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(0),
                max_val: Some(250),
                enums: &[],
            },
            Rule {
                wire: "nextToken",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(4096),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[
            ("NextToken", K::Str),
            ("WirelessDeviceImportTaskList", K::List),
        ],
        list_field: Some("WirelessDeviceImportTaskList"),
        list_elems: &[
            ("Id", K::Str),
            ("Arn", K::Str),
            ("DestinationName", K::Str),
            ("Positioning", K::Str),
            ("Sidewalk", K::Struct),
            ("CreationTime", K::Ts),
            ("Status", K::Str),
            ("StatusReason", K::Str),
            ("InitializedImportedDeviceCount", K::Int),
            ("PendingImportedDeviceCount", K::Int),
            ("OnboardedImportedDeviceCount", K::Int),
            ("FailedImportedDeviceCount", K::Int),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListWirelessDevices",
        method: "GET",
        segs: &[Seg::Fixed("wireless-devices")],
        verb: Verb::List,
        rtype: "wireless-devices",
        nlabels: 0,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "maxResults",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(0),
                max_val: Some(250),
                enums: &[],
            },
            Rule {
                wire: "nextToken",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(4096),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "destinationName",
                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: "deviceProfileId",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "serviceProfileId",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "wirelessDeviceType",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["Sidewalk", "LoRaWAN"],
            },
            Rule {
                wire: "fuotaTaskId",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "multicastGroupId",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("NextToken", K::Str), ("WirelessDeviceList", K::List)],
        list_field: Some("WirelessDeviceList"),
        list_elems: &[
            ("Arn", K::Str),
            ("Id", K::Str),
            ("Type", K::Str),
            ("Name", K::Str),
            ("DestinationName", K::Str),
            ("LastUplinkReceivedAt", K::Str),
            ("LoRaWAN", K::Struct),
            ("Sidewalk", K::Struct),
            ("FuotaDeviceStatus", K::Str),
            ("MulticastDeviceStatus", K::Str),
            ("McGroupId", K::Int),
            ("Positioning", K::Str),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListWirelessGatewayTaskDefinitions",
        method: "GET",
        segs: &[Seg::Fixed("wireless-gateway-task-definitions")],
        verb: Verb::List,
        rtype: "wireless-gateway-task-definitions",
        nlabels: 0,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "maxResults",
                src: Src::Query,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(0),
                max_val: Some(250),
                enums: &[],
            },
            Rule {
                wire: "nextToken",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(4096),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "taskDefinitionType",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["UPDATE"],
            },
        ],
        omembers: &[("NextToken", K::Str), ("TaskDefinitions", K::List)],
        list_field: Some("TaskDefinitions"),
        list_elems: &[("Id", K::Str), ("LoRaWAN", K::Struct), ("Arn", K::Str)],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ListWirelessGateways",
        method: "GET",
        segs: &[Seg::Fixed("wireless-gateways")],
        verb: Verb::List,
        rtype: "wireless-gateways",
        nlabels: 0,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "nextToken",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(4096),
                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(0),
                max_val: Some(250),
                enums: &[],
            },
        ],
        omembers: &[("NextToken", K::Str), ("WirelessGatewayList", K::List)],
        list_field: Some("WirelessGatewayList"),
        list_elems: &[
            ("Arn", K::Str),
            ("Id", K::Str),
            ("Name", K::Str),
            ("Description", K::Str),
            ("LoRaWAN", K::Struct),
            ("LastUplinkReceivedAt", K::Str),
        ],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "PutPositionConfiguration",
        method: "PUT",
        segs: &[
            Seg::Fixed("position-configurations"),
            Seg::Label("ResourceIdentifier"),
        ],
        verb: Verb::Action,
        rtype: "position-configurations",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "ResourceIdentifier",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "resourceType",
                src: Src::Query,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["WirelessDevice", "WirelessGateway"],
            },
            Rule {
                wire: "Destination",
                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: "PutResourceLogLevel",
        method: "PUT",
        segs: &[Seg::Fixed("log-levels"), Seg::Label("ResourceIdentifier")],
        verb: Verb::Action,
        rtype: "log-levels",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "ResourceIdentifier",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "resourceType",
                src: Src::Query,
                req: true,
                kind: K::Str,
                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: &["INFO", "ERROR", "DISABLED"],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ResetAllResourceLogLevels",
        method: "DELETE",
        segs: &[Seg::Fixed("log-levels")],
        verb: Verb::Action,
        rtype: "log-levels",
        nlabels: 0,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "ResetResourceLogLevel",
        method: "DELETE",
        segs: &[Seg::Fixed("log-levels"), Seg::Label("ResourceIdentifier")],
        verb: Verb::Action,
        rtype: "log-levels",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "ResourceIdentifier",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "resourceType",
                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: "SendDataToMulticastGroup",
        method: "POST",
        segs: &[
            Seg::Fixed("multicast-groups"),
            Seg::Label("Id"),
            Seg::Fixed("data"),
        ],
        verb: Verb::Action,
        rtype: "multicast-groups",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "ConflictException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "Id",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "PayloadData",
                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: "WirelessMetadata",
                src: Src::Body,
                req: true,
                kind: K::Struct,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("MessageId", K::Str)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "SendDataToWirelessDevice",
        method: "POST",
        segs: &[
            Seg::Fixed("wireless-devices"),
            Seg::Label("Id"),
            Seg::Fixed("data"),
        ],
        verb: Verb::Action,
        rtype: "wireless-devices",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "Id",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "TransmitMode",
                src: Src::Body,
                req: true,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(0),
                max_val: Some(1),
                enums: &[],
            },
            Rule {
                wire: "PayloadData",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(2048),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("MessageId", K::Str)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "StartBulkAssociateWirelessDeviceWithMulticastGroup",
        method: "PATCH",
        segs: &[
            Seg::Fixed("multicast-groups"),
            Seg::Label("Id"),
            Seg::Fixed("bulk"),
        ],
        verb: Verb::Action,
        rtype: "multicast-groups",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "Id",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "QueryString",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(4096),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "Tags",
                src: Src::Body,
                req: false,
                kind: K::List,
                min_len: Some(0),
                max_len: Some(200),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "StartBulkDisassociateWirelessDeviceFromMulticastGroup",
        method: "POST",
        segs: &[
            Seg::Fixed("multicast-groups"),
            Seg::Label("Id"),
            Seg::Fixed("bulk"),
        ],
        verb: Verb::Action,
        rtype: "multicast-groups",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "Id",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "QueryString",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(4096),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "Tags",
                src: Src::Body,
                req: false,
                kind: K::List,
                min_len: Some(0),
                max_len: Some(200),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "StartFuotaTask",
        method: "PUT",
        segs: &[Seg::Fixed("fuota-tasks"), Seg::Label("Id")],
        verb: Verb::Action,
        rtype: "fuota-tasks",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "ConflictException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[Rule {
            wire: "Id",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(0),
            max_len: Some(256),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "StartMulticastGroupSession",
        method: "PUT",
        segs: &[
            Seg::Fixed("multicast-groups"),
            Seg::Label("Id"),
            Seg::Fixed("session"),
        ],
        verb: Verb::Action,
        rtype: "multicast-groups",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "ConflictException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "Id",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "LoRaWAN",
                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: "StartSingleWirelessDeviceImportTask",
        method: "POST",
        segs: &[Seg::Fixed("wireless_single_device_import_task")],
        verb: Verb::Action,
        rtype: "wireless_single_device_import_task",
        nlabels: 0,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "ConflictException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "DestinationName",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "ClientRequestToken",
                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: "Tags",
                src: Src::Body,
                req: false,
                kind: K::List,
                min_len: Some(0),
                max_len: Some(200),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "Positioning",
                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: "Sidewalk",
                src: Src::Body,
                req: true,
                kind: K::Struct,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("Id", K::Str), ("Arn", K::Str)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "StartWirelessDeviceImportTask",
        method: "POST",
        segs: &[Seg::Fixed("wireless_device_import_task")],
        verb: Verb::Action,
        rtype: "wireless_device_import_task",
        nlabels: 0,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "ConflictException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "DestinationName",
                src: Src::Body,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(128),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "ClientRequestToken",
                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: "Tags",
                src: Src::Body,
                req: false,
                kind: K::List,
                min_len: Some(0),
                max_len: Some(200),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "Positioning",
                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: "Sidewalk",
                src: Src::Body,
                req: true,
                kind: K::Struct,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[("Id", K::Str), ("Arn", K::Str)],
        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: &[
            "ConflictException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "TooManyTagsException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "resourceArn",
                src: Src::Query,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(1011),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "Tags",
                src: Src::Body,
                req: true,
                kind: K::List,
                min_len: Some(0),
                max_len: Some(200),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "TestWirelessDevice",
        method: "POST",
        segs: &[
            Seg::Fixed("wireless-devices"),
            Seg::Label("Id"),
            Seg::Fixed("test"),
        ],
        verb: Verb::Action,
        rtype: "wireless-devices",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[Rule {
            wire: "Id",
            src: Src::Label,
            req: true,
            kind: K::Str,
            min_len: Some(0),
            max_len: Some(256),
            min_val: None,
            max_val: None,
            enums: &[],
        }],
        omembers: &[("Result", K::Str)],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "UntagResource",
        method: "DELETE",
        segs: &[Seg::Fixed("tags")],
        verb: Verb::Action,
        rtype: "tags",
        nlabels: 0,
        has_input: true,
        errors: &[
            "ConflictException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "resourceArn",
                src: Src::Query,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(1011),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "tagKeys",
                src: Src::Query,
                req: true,
                kind: K::List,
                min_len: Some(0),
                max_len: Some(200),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "UpdateDestination",
        method: "PATCH",
        segs: &[Seg::Fixed("destinations"), Seg::Label("Name")],
        verb: Verb::Update,
        rtype: "destinations",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "Name",
                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: "ExpressionType",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["RuleName", "MqttTopic"],
            },
            Rule {
                wire: "Expression",
                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: "Description",
                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: "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: "UpdateEventConfigurationByResourceTypes",
        method: "PATCH",
        segs: &[Seg::Fixed("event-configurations-resource-types")],
        verb: Verb::Action,
        rtype: "event-configurations-resource-types",
        nlabels: 0,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "UpdateFuotaTask",
        method: "PATCH",
        segs: &[Seg::Fixed("fuota-tasks"), Seg::Label("Id")],
        verb: Verb::Update,
        rtype: "fuota-tasks",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "ConflictException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "Id",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "Name",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                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(2048),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "FirmwareUpdateImage",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(4096),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "FirmwareUpdateRole",
                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: "RedundancyPercent",
                src: Src::Body,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(0),
                max_val: Some(100),
                enums: &[],
            },
            Rule {
                wire: "FragmentSizeBytes",
                src: Src::Body,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "FragmentIntervalMS",
                src: Src::Body,
                req: false,
                kind: K::Int,
                min_len: None,
                max_len: None,
                min_val: Some(1),
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "Descriptor",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(332),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "UpdateLogLevelsByResourceTypes",
        method: "POST",
        segs: &[Seg::Fixed("log-levels")],
        verb: Verb::Action,
        rtype: "log-levels",
        nlabels: 0,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "ConflictException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        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: &["INFO", "ERROR", "DISABLED"],
        }],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "UpdateMetricConfiguration",
        method: "PUT",
        segs: &[Seg::Fixed("metric-configuration")],
        verb: Verb::Action,
        rtype: "metric-configuration",
        nlabels: 0,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "ConflictException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "UpdateMulticastGroup",
        method: "PATCH",
        segs: &[Seg::Fixed("multicast-groups"), Seg::Label("Id")],
        verb: Verb::Update,
        rtype: "multicast-groups",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "ConflictException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "Id",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "Name",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                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(2048),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "UpdateNetworkAnalyzerConfiguration",
        method: "PATCH",
        segs: &[
            Seg::Fixed("network-analyzer-configurations"),
            Seg::Label("ConfigurationName"),
        ],
        verb: Verb::Update,
        rtype: "network-analyzer-configurations",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "ConfigurationName",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(1),
                max_len: Some(1024),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "WirelessDevicesToAdd",
                src: Src::Body,
                req: false,
                kind: K::List,
                min_len: Some(0),
                max_len: Some(250),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "WirelessDevicesToRemove",
                src: Src::Body,
                req: false,
                kind: K::List,
                min_len: Some(0),
                max_len: Some(250),
                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(2048),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "MulticastGroupsToAdd",
                src: Src::Body,
                req: false,
                kind: K::List,
                min_len: Some(0),
                max_len: Some(10),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "MulticastGroupsToRemove",
                src: Src::Body,
                req: false,
                kind: K::List,
                min_len: Some(0),
                max_len: Some(10),
                min_val: None,
                max_val: None,
                enums: &[],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "UpdatePartnerAccount",
        method: "PATCH",
        segs: &[
            Seg::Fixed("partner-accounts"),
            Seg::Label("PartnerAccountId"),
        ],
        verb: Verb::Update,
        rtype: "partner-accounts",
        nlabels: 1,
        has_input: true,
        errors: &[
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "Sidewalk",
                src: Src::Body,
                req: true,
                kind: K::Struct,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "PartnerAccountId",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "partnerType",
                src: Src::Query,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["Sidewalk"],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "UpdatePosition",
        method: "PATCH",
        segs: &[Seg::Fixed("positions"), Seg::Label("ResourceIdentifier")],
        verb: Verb::Update,
        rtype: "positions",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "ResourceIdentifier",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "resourceType",
                src: Src::Query,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["WirelessDevice", "WirelessGateway"],
            },
            Rule {
                wire: "Position",
                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: "UpdateResourceEventConfiguration",
        method: "PATCH",
        segs: &[Seg::Fixed("event-configurations"), Seg::Label("Identifier")],
        verb: Verb::Update,
        rtype: "event-configurations",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "ConflictException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "Identifier",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "identifierType",
                src: Src::Query,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[
                    "PartnerAccountId",
                    "DevEui",
                    "GatewayEui",
                    "WirelessDeviceId",
                    "WirelessGatewayId",
                ],
            },
            Rule {
                wire: "partnerType",
                src: Src::Query,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["Sidewalk"],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "UpdateResourcePosition",
        method: "PATCH",
        segs: &[
            Seg::Fixed("resource-positions"),
            Seg::Label("ResourceIdentifier"),
        ],
        verb: Verb::Update,
        rtype: "resource-positions",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "ResourceIdentifier",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "resourceType",
                src: Src::Query,
                req: true,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["WirelessDevice", "WirelessGateway"],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "UpdateWirelessDevice",
        method: "PATCH",
        segs: &[Seg::Fixed("wireless-devices"), Seg::Label("Id")],
        verb: Verb::Update,
        rtype: "wireless-devices",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "Id",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "DestinationName",
                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: "Name",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                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(2048),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "Positioning",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: None,
                max_len: None,
                min_val: None,
                max_val: None,
                enums: &["Enabled", "Disabled"],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
    OpMeta {
        op: "UpdateWirelessDeviceImportTask",
        method: "PATCH",
        segs: &[Seg::Fixed("wireless_device_import_task"), Seg::Label("Id")],
        verb: Verb::Update,
        rtype: "wireless_device_import_task",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "ConflictException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "Id",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "Sidewalk",
                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: "UpdateWirelessGateway",
        method: "PATCH",
        segs: &[Seg::Fixed("wireless-gateways"), Seg::Label("Id")],
        verb: Verb::Update,
        rtype: "wireless-gateways",
        nlabels: 1,
        has_input: true,
        errors: &[
            "AccessDeniedException",
            "InternalServerException",
            "ResourceNotFoundException",
            "ThrottlingException",
            "ValidationException",
        ],
        rules: &[
            Rule {
                wire: "Id",
                src: Src::Label,
                req: true,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "Name",
                src: Src::Body,
                req: false,
                kind: K::Str,
                min_len: Some(0),
                max_len: Some(256),
                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(2048),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "JoinEuiFilters",
                src: Src::Body,
                req: false,
                kind: K::List,
                min_len: Some(0),
                max_len: Some(3),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "NetIdFilters",
                src: Src::Body,
                req: false,
                kind: K::List,
                min_len: Some(0),
                max_len: Some(10),
                min_val: None,
                max_val: None,
                enums: &[],
            },
            Rule {
                wire: "MaxEirp",
                src: Src::Body,
                req: false,
                kind: K::Num,
                min_len: None,
                max_len: None,
                min_val: Some(0),
                max_val: Some(30),
                enums: &[],
            },
        ],
        omembers: &[],
        list_field: None,
        list_elems: &[],
        list_scalar: false,
        req_payload: false,
    },
];

pub static ACTIONS: &[&str] = &[
    "AssociateAwsAccountWithPartnerAccount",
    "AssociateMulticastGroupWithFuotaTask",
    "AssociateWirelessDeviceWithFuotaTask",
    "AssociateWirelessDeviceWithMulticastGroup",
    "AssociateWirelessDeviceWithThing",
    "AssociateWirelessGatewayWithCertificate",
    "AssociateWirelessGatewayWithThing",
    "CancelMulticastGroupSession",
    "CreateDestination",
    "CreateDeviceProfile",
    "CreateFuotaTask",
    "CreateMulticastGroup",
    "CreateNetworkAnalyzerConfiguration",
    "CreateServiceProfile",
    "CreateWirelessDevice",
    "CreateWirelessGateway",
    "CreateWirelessGatewayTask",
    "CreateWirelessGatewayTaskDefinition",
    "DeleteDestination",
    "DeleteDeviceProfile",
    "DeleteFuotaTask",
    "DeleteMulticastGroup",
    "DeleteNetworkAnalyzerConfiguration",
    "DeleteQueuedMessages",
    "DeleteServiceProfile",
    "DeleteWirelessDevice",
    "DeleteWirelessDeviceImportTask",
    "DeleteWirelessGateway",
    "DeleteWirelessGatewayTask",
    "DeleteWirelessGatewayTaskDefinition",
    "DeregisterWirelessDevice",
    "DisassociateAwsAccountFromPartnerAccount",
    "DisassociateMulticastGroupFromFuotaTask",
    "DisassociateWirelessDeviceFromFuotaTask",
    "DisassociateWirelessDeviceFromMulticastGroup",
    "DisassociateWirelessDeviceFromThing",
    "DisassociateWirelessGatewayFromCertificate",
    "DisassociateWirelessGatewayFromThing",
    "GetDestination",
    "GetDeviceProfile",
    "GetEventConfigurationByResourceTypes",
    "GetFuotaTask",
    "GetLogLevelsByResourceTypes",
    "GetMetricConfiguration",
    "GetMetrics",
    "GetMulticastGroup",
    "GetMulticastGroupSession",
    "GetNetworkAnalyzerConfiguration",
    "GetPartnerAccount",
    "GetPosition",
    "GetPositionConfiguration",
    "GetPositionEstimate",
    "GetResourceEventConfiguration",
    "GetResourceLogLevel",
    "GetResourcePosition",
    "GetServiceEndpoint",
    "GetServiceProfile",
    "GetWirelessDevice",
    "GetWirelessDeviceImportTask",
    "GetWirelessDeviceStatistics",
    "GetWirelessGateway",
    "GetWirelessGatewayCertificate",
    "GetWirelessGatewayFirmwareInformation",
    "GetWirelessGatewayStatistics",
    "GetWirelessGatewayTask",
    "GetWirelessGatewayTaskDefinition",
    "ListDestinations",
    "ListDeviceProfiles",
    "ListDevicesForWirelessDeviceImportTask",
    "ListEventConfigurations",
    "ListFuotaTasks",
    "ListMulticastGroups",
    "ListMulticastGroupsByFuotaTask",
    "ListNetworkAnalyzerConfigurations",
    "ListPartnerAccounts",
    "ListPositionConfigurations",
    "ListQueuedMessages",
    "ListServiceProfiles",
    "ListTagsForResource",
    "ListWirelessDeviceImportTasks",
    "ListWirelessDevices",
    "ListWirelessGatewayTaskDefinitions",
    "ListWirelessGateways",
    "PutPositionConfiguration",
    "PutResourceLogLevel",
    "ResetAllResourceLogLevels",
    "ResetResourceLogLevel",
    "SendDataToMulticastGroup",
    "SendDataToWirelessDevice",
    "StartBulkAssociateWirelessDeviceWithMulticastGroup",
    "StartBulkDisassociateWirelessDeviceFromMulticastGroup",
    "StartFuotaTask",
    "StartMulticastGroupSession",
    "StartSingleWirelessDeviceImportTask",
    "StartWirelessDeviceImportTask",
    "TagResource",
    "TestWirelessDevice",
    "UntagResource",
    "UpdateDestination",
    "UpdateEventConfigurationByResourceTypes",
    "UpdateFuotaTask",
    "UpdateLogLevelsByResourceTypes",
    "UpdateMetricConfiguration",
    "UpdateMulticastGroup",
    "UpdateNetworkAnalyzerConfiguration",
    "UpdatePartnerAccount",
    "UpdatePosition",
    "UpdateResourceEventConfiguration",
    "UpdateResourcePosition",
    "UpdateWirelessDevice",
    "UpdateWirelessDeviceImportTask",
    "UpdateWirelessGateway",
];