;ELC
;;; Compiled
;;; in Emacs version 28.2
;;; with all optimizations.



(byte-code "\300\301!\210\300\302!\210\300\303!\210\300\304!\210\300\305!\210\300\306!\210\300\307!\210\300\310!\210\300\311!\210\300\312!\210\300\313!\207" [require cl-lib xml xsd-regexp rng-xsd rng-dt warnings url url-http url-util url-vars mm-decode] 2)
#@101 Display a warning MESSAGE with ARGS, using the `soap-client' warning type.

(fn MESSAGE &rest ARGS)
(defalias 'soap-warning #[385 "\300\301\302\303#\304#\207" [display-warning soap-client apply format :warning] 8 (#$ . 342)])
(byte-code "\300\301\302\303#\304\301\305\306#\210\307\310\311\312\313\314\315\316&\207" [function-put soap-warning speed -1 put byte-optimizer byte-compile-inline-expand custom-declare-group soap-client nil "Access SOAP web services from Emacs." :version "24.1" :group tools] 9)
#@56 A list of well known xml namespaces and their aliases.
(defconst soap-well-known-xmlns '(("apachesoap" . "http://xml.apache.org/xml-soap") ("soapenc" . "http://schemas.xmlsoap.org/soap/encoding/") ("wsdl" . "http://schemas.xmlsoap.org/wsdl/") ("wsdlsoap" . "http://schemas.xmlsoap.org/wsdl/soap/") ("xsd" . "http://www.w3.org/2001/XMLSchema") ("xsi" . "http://www.w3.org/2001/XMLSchema-instance") ("wsa" . "http://www.w3.org/2005/08/addressing") ("wsaw" . "http://www.w3.org/2006/05/addressing/wsdl") ("soap" . "http://schemas.xmlsoap.org/soap/envelope/") ("soap12" . "http://schemas.xmlsoap.org/wsdl/soap12/") ("http" . "http://schemas.xmlsoap.org/wsdl/http/") ("mime" . "http://schemas.xmlsoap.org/wsdl/mime/") ("xml" . "http://www.w3.org/XML/1998/namespace")) (#$ . 857))
#@113 A list of local namespace aliases.
This is a dynamically bound variable, controlled by
`soap-with-local-xmlns'.
(defvar soap-local-xmlns '(("xml" . "http://www.w3.org/XML/1998/namespace")) (#$ . 1639))
#@151 The default XML namespaces.
Names in this namespace will be unqualified.  This is a
dynamically bound variable, controlled by
`soap-with-local-xmlns'
(defvar soap-default-xmlns nil (#$ . 1848))
#@215 The target XML namespace.
New XSD elements will be defined in this namespace, unless they
are fully qualified for a different namespace.  This is a
dynamically bound variable, controlled by
`soap-with-local-xmlns'
(defvar soap-target-xmlns nil (#$ . 2049))
#@103 The current WSDL document used when decoding the SOAP response.
This is a dynamically bound variable.
(defvar soap-current-wsdl nil (#$ . 2313))
#@288 Return local variant of WELL-KNOWN-NAME.
This is done by looking up the namespace in the
`soap-well-known-xmlns' table and resolving the namespace to
the local name based on the current local translation table
`soap-local-xmlns'.  See also `soap-with-local-xmlns'.

(fn WELL-KNOWN-NAME)
(defalias 'soap-wk2l #[257 "\2119\203\303
!\202\f\211\304\305\"\203E\306\307\"\306\310\"\311\"A\211	\232\20319\203/\312!\207
\207\313
\n\"@\211\314Q9\203D\312
!\207\207
\207" [soap-well-known-xmlns soap-default-xmlns soap-local-xmlns symbol-name string-match "^\\(.*\\):\\(.*\\)$" match-string 1 2 assoc intern rassoc ":"] 9 (#$ . 2465)])
#@277 Convert LOCAL-NAME into a well known name.
The namespace of LOCAL-NAME is looked up in the
`soap-well-known-xmlns' table and a well known namespace tag is
used in the name.

nil is returned if there is no well-known namespace for the
namespace of LOCAL-NAME.

(fn LOCAL-NAME)
(defalias 'soap-l2wk #[257 "\2119\203\303
!\202\f\211\304\211\305\306\"\2035\307\310\"\262
\307\311\"\312
\"A\262\2041\313\314#\210\210\202;\262
	\262
\203[\315\n\"@\211\205Z\211\316Q9\203W\317
!\202X\211\262
\207\207" [soap-local-xmlns soap-default-xmlns soap-well-known-xmlns symbol-name nil string-match "^\\(.*\\):\\(.*\\)$" match-string 2 1 assoc error "Soap-l2wk(%s): no namespace for alias %s" rassoc ":" intern] 9 (#$ . 3115)])
#@598 Convert LOCAL-NAME into a fully qualified name.
A fully qualified name is a cons of the namespace name and the
name of the element itself.  For example "xsd:string" is
converted to ("http://www.w3.org/2001/XMLSchema" . "string").

The USE-TNS argument specifies what to do when LOCAL-NAME has no
namespace tag.  If USE-TNS is non-nil, the `soap-target-xmlns'
will be used as the element's namespace, otherwise
`soap-default-xmlns' will be used.

This is needed because different parts of a WSDL document can use
different namespace aliases for the same element.

(fn LOCAL-NAME &optional USE-TNS)
(defalias 'soap-l2fq #[513 "
9\203\303!\202\f
\304\305\"\203/\306\307\"\306\310\"\311\"A\211\203(\211B\207\312\313#\207
\2037	\2028\n
B\207" [soap-local-xmlns soap-target-xmlns soap-default-xmlns symbol-name string-match "^\\(.*\\):\\(.*\\)$" match-string 1 2 assoc error "Soap-l2fq(%s): unknown alias %s"] 10 (#$ . 3858)])
#@131 Return t if NAME is a valid name for XMLSchema types.
A valid name is either a string or a cons of (NAMESPACE . NAME).

(fn NAME)
(defalias 'soap-name-p #[257 "\211;\206\211:\205\211@;\205\211A;\207" [] 2 (#$ . 4803)])
#@100 Return a namespace alias table for NODE by extending XMLNS-TABLE.

(fn NODE &optional XMLNS-TABLE)
(defalias 'soap-extract-xmlns #[513 "\300\211\211\211A@\262
\211\203H\211@\301
@!
A
\302\230\203!\262\210\202A
\303\230\203-\262\210\202A\304\305\"\203?\306\307\"
BB\262\266
A\266\202\202	\210\310\311\"\211\203r
\203r

A\232\204~\312\211@\262
C\313\314\315\316#\317#\266\202\211\203~
\204~\211A\262\210

\320\"E\207" [nil symbol-name "targetNamespace" "xmlns" string-match "^xmlns:\\(.*\\)$" match-string 1 assoc "tns" "soap-extract-xmlns(%s): tns alias and targetNamespace mismatch" display-warning soap-client apply format :warning append] 14 (#$ . 5035)])
#@79 Install a local alias table from NODE and execute BODY.

(fn NODE &rest BODY)
(defalias 'soap-with-local-xmlns '(macro . #[385 "\300\301!\302
\303\304BBDC\302\305\306\307\310E\311BBD\312\306\307\313E\314BBD\315\307\316EDEBBE\207" [make-symbol "xmlns" let soap-extract-xmlns (soap-local-xmlns) soap-default-xmlns or nth 0 (soap-default-xmlns) soap-target-xmlns 1 (soap-target-xmlns) soap-local-xmlns 2] 12 (#$ . 5732)]))
(byte-code "\300\301\302\303#\210\304\301\305\306#\300\207" [put soap-with-local-xmlns edebug-form-spec (form &rest form) function-put lisp-indent-function 1] 4)
#@110 Return the target namespace of NODE.
This is the namespace in which new elements will be defined.

(fn NODE)
(defalias 'soap-get-target-namespace #[257 "\302
\303\"\206\304\305\"A\206	\207" [soap-local-xmlns soap-target-xmlns xml-get-attribute-or-nil targetNamespace assoc "tns"] 4 (#$ . 6329)])
#@148 Return the children of NODE named CHILD-NAME.
This is the same as `xml-get-children', but CHILD-NAME can have
namespace tag.

(fn NODE CHILD-NAME)
(defalias 'soap-xml-get-children1 #[514 "\303\211AA\262
\211\203N\211@\211:\203G\304
\"\211@\206	
A@\206#\n\3058\30618\307\211@\262
!0\202:\210\303+=\262
\203G\211B\262
A\266\202\202\210\211\237\207" [soap-local-xmlns soap-default-xmlns soap-target-xmlns nil soap-extract-xmlns 2 (error) soap-l2wk] 10 (#$ . 6637)])
#@78 Return the first child of NODE whose name is a member of SET.

(fn NODE SET)
(defalias 'soap-xml-node-find-matching-child #[514 "\30020
\211AA\262
\211\205-\211@\211:\203&\301
\211@\262
!>\203&\302\300\"\210
A\266\202\202\n\262
0\207" [found soap-l2wk throw] 7 (#$ . 7126)])
#@178 Return the NODE's ATTRIBUTE, or nil if it does not exist.
This is the same as `xml-get-attribute-or-nil', but ATTRIBUTE can
be tagged with a namespace tag.

(fn NODE ATTRIBUTE)
(defalias 'soap-xml-get-attribute-or-nil1 #[514 "\3032M\304\"\211@\206	
A@\206\n\3058\211A@\262
\211\205G\211@\30613\307
@!0\2025\210\310=\203@\311\303A\"\210
A\266\202\202!\262
+\262
0\207" [soap-local-xmlns soap-default-xmlns soap-target-xmlns found soap-extract-xmlns 2 (error) soap-l2wk nil throw] 8 (#$ . 7415)])
#@71 compiler-macro for inlining `soap-element-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-element-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-element-p (and (memq (type-of cl-x) cl-struct-soap-element-tags) t)) nil] 9 (#$ . 7935)])
(put 'soap-element-p 'compiler-macro 'soap-element-p--cmacro)
#@13 

(fn CL-X)
(defalias 'soap-element-p #[257 "\301
!>\205	\302\207" [cl-struct-soap-element-tags type-of t] 3 (#$ . 8281)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put soap-element-p side-effect-free error-free put soap-element cl-deftype-satisfies] 5)
#@74 compiler-macro for inlining `soap-element-name'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-element-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-element-name (progn (or (soap-element-p cl-x) (signal 'wrong-type-argument (list 'soap-element cl-x))) (aref cl-x 1))) nil] 9 (#$ . 8563)])
(put 'soap-element-name 'compiler-macro 'soap-element-name--cmacro)
#@62 Access slot "name" of `soap-element' struct CL-X.

(fn CL-X)
(defalias 'soap-element-name #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-element-tags type-of signal wrong-type-argument soap-element 1] 5 (#$ . 8971)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-element-name side-effect-free t] 4)
#@83 compiler-macro for inlining `soap-element-namespace-tag'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-element-namespace-tag--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-element-namespace-tag (progn (or (soap-element-p cl-x) (signal 'wrong-type-argument (list 'soap-element cl-x))) (aref cl-x 2))) nil] 9 (#$ . 9313)])
(put 'soap-element-namespace-tag 'compiler-macro 'soap-element-namespace-tag--cmacro)
#@71 Access slot "namespace-tag" of `soap-element' struct CL-X.

(fn CL-X)
(defalias 'soap-element-namespace-tag #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-element-tags type-of signal wrong-type-argument soap-element 2] 5 (#$ . 9766)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put soap-element-namespace-tag side-effect-free t defalias copy-soap-element copy-sequence] 4)
#@99 compiler-macro for inlining `make-soap-element'.

(fn CL-WHOLE &cl-quote &key NAME NAMESPACE-TAG)
(defalias 'make-soap-element--cmacro #[385 "\300
\301\"A@\300\302\"A@\211\2037\211@\303>\203 \211AA\262
\202
\304>A@\203.\305\262
\202
\306\307@\"\210\202
\210\310\311\312\305\305&\207" [plist-member :name :namespace-tag (:name :namespace-tag :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag)" cl--defsubst-expand (name namespace-tag) (cl-block make-soap-element (record 'soap-element name namespace-tag))] 12 (#$ . 10186)])
(put 'make-soap-element 'compiler-macro 'make-soap-element--cmacro)
#@79 Constructor for objects of type `soap-element'.

(fn &key NAME NAMESPACE-TAG)
(defalias 'make-soap-element #[128 "\300
\301\"A@\300\302\"A@\211\2037\211@\303>\203 \211AA\262
\202
\304>A@\203.\305\262
\202
\306\307@\"\210\202
\210\310\311#\207" [plist-member :name :namespace-tag (:name :namespace-tag :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag)" record soap-element] 7 (#$ . 10852)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put make-soap-element side-effect-free t cl-struct-define soap-element nil cl-structure-object record ((cl-tag-slot) (name) (namespace-tag)) cl-struct-soap-element-tags] 11)
#@132 Return a fully qualified name for ELEMENT.
A fq name is the concatenation of the namespace tag and the
element name.

(fn ELEMENT)
(defalias 'soap-element-fq-name #[257 "\301
!>\204\302\303\304D\"\210\211\305H\203<\301
!>\204$\302\303\304D\"\210\211\305H\306\301!>\2047\302\303\304D\"\210\307HQ\207\301
!>\204K\302\303\304D\"\210\211\307H\203d\301
!>\204`\302\303\304D\"\210\211\307H\207\310\207" [cl-struct-soap-element-tags type-of signal wrong-type-argument soap-element 2 ":" 1 "*unnamed*"] 7 (#$ . 11574)])
#@78 compiler-macro for inlining `soap-namespace-link-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-namespace-link-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-namespace-link-p (and (memq (type-of cl-x) cl-struct-soap-namespace-link-tags) t)) nil] 9 (#$ . 12112)])
(put 'soap-namespace-link-p 'compiler-macro 'soap-namespace-link-p--cmacro)
#@13 

(fn CL-X)
(defalias 'soap-namespace-link-p #[257 "\301
!>\205	\302\207" [cl-struct-soap-namespace-link-tags type-of t] 3 (#$ . 12501)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put soap-namespace-link-p side-effect-free error-free put soap-namespace-link cl-deftype-satisfies] 5)
#@81 compiler-macro for inlining `soap-namespace-link-name'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-namespace-link-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-namespace-link-name (progn (or (soap-namespace-link-p cl-x) (signal 'wrong-type-argument (list 'soap-namespace-link cl-x))) (aref cl-x 1))) nil] 9 (#$ . 12812)])
(put 'soap-namespace-link-name 'compiler-macro 'soap-namespace-link-name--cmacro)
#@69 Access slot "name" of `soap-namespace-link' struct CL-X.

(fn CL-X)
(defalias 'soap-namespace-link-name #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-namespace-link-tags type-of signal wrong-type-argument soap-namespace-link 1] 5 (#$ . 13270)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-namespace-link-name side-effect-free t] 4)
#@90 compiler-macro for inlining `soap-namespace-link-namespace-tag'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-namespace-link-namespace-tag--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-namespace-link-namespace-tag (progn (or (soap-namespace-link-p cl-x) (signal 'wrong-type-argument (list 'soap-namespace-link cl-x))) (aref cl-x 2))) nil] 9 (#$ . 13648)])
(put 'soap-namespace-link-namespace-tag 'compiler-macro 'soap-namespace-link-namespace-tag--cmacro)
#@78 Access slot "namespace-tag" of `soap-namespace-link' struct CL-X.

(fn CL-X)
(defalias 'soap-namespace-link-namespace-tag #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-namespace-link-tags type-of signal wrong-type-argument soap-namespace-link 2] 5 (#$ . 14151)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-namespace-link-namespace-tag side-effect-free t] 4)
#@83 compiler-macro for inlining `soap-namespace-link-target'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-namespace-link-target--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-namespace-link-target (progn (or (soap-namespace-link-p cl-x) (signal 'wrong-type-argument (list 'soap-namespace-link cl-x))) (aref cl-x 3))) nil] 9 (#$ . 14556)])
(put 'soap-namespace-link-target 'compiler-macro 'soap-namespace-link-target--cmacro)
#@71 Access slot "target" of `soap-namespace-link' struct CL-X.

(fn CL-X)
(defalias 'soap-namespace-link-target #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-namespace-link-tags type-of signal wrong-type-argument soap-namespace-link 3] 5 (#$ . 15024)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put soap-namespace-link-target side-effect-free t defalias copy-soap-namespace-link copy-sequence] 4)
#@113 compiler-macro for inlining `make-soap-namespace-link'.

(fn CL-WHOLE &cl-quote &key NAME NAMESPACE-TAG TARGET)
(defalias 'make-soap-namespace-link--cmacro #[385 "\300
\301\"A@\300\302\"A@\300\303\"A@\211\203=\211@\304>\203&\211AA\262
\202\305>A@\2034\306\262
\202\307\310@\"\210\202\210\311\312\313\306\306&\207" [plist-member :name :namespace-tag :target (:name :namespace-tag :target :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag :target)" cl--defsubst-expand (name namespace-tag target) (cl-block make-soap-namespace-link (record 'soap-namespace-link name namespace-tag target))] 14 (#$ . 15467)])
(put 'make-soap-namespace-link 'compiler-macro 'make-soap-namespace-link--cmacro)
#@93 Constructor for objects of type `soap-namespace-link'.

(fn &key NAME NAMESPACE-TAG TARGET)
(defalias 'make-soap-namespace-link #[128 "\300
\301\"A@\300\302\"A@\300\303\"A@\211\203=\211@\304>\203&\211AA\262
\202\305>A@\2034\306\262
\202\307\310@\"\210\202\210\311\312$\207" [plist-member :name :namespace-tag :target (:name :namespace-tag :target :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag :target)" record soap-namespace-link] 9 (#$ . 16235)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put make-soap-namespace-link side-effect-free t cl-struct-define soap-namespace-link nil soap-element record ((cl-tag-slot) (name nil) (namespace-tag nil) (target)) cl-struct-soap-namespace-link-tags] 11)
#@73 compiler-macro for inlining `soap-namespace-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-namespace-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-namespace-p (and (memq (type-of cl-x) cl-struct-soap-namespace-tags) t)) nil] 9 (#$ . 17053)])
(put 'soap-namespace-p 'compiler-macro 'soap-namespace-p--cmacro)
#@13 

(fn CL-X)
(defalias 'soap-namespace-p #[257 "\301
!>\205	\302\207" [cl-struct-soap-namespace-tags type-of t] 3 (#$ . 17412)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put soap-namespace-p side-effect-free error-free put soap-namespace cl-deftype-satisfies] 5)
#@76 compiler-macro for inlining `soap-namespace-name'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-namespace-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-namespace-name (progn (or (soap-namespace-p cl-x) (signal 'wrong-type-argument (list 'soap-namespace cl-x))) (aref cl-x 1))) nil] 9 (#$ . 17703)])
(put 'soap-namespace-name 'compiler-macro 'soap-namespace-name--cmacro)
#@64 Access slot "name" of `soap-namespace' struct CL-X.

(fn CL-X)
(defalias 'soap-namespace-name #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-namespace-tags type-of signal wrong-type-argument soap-namespace 1] 5 (#$ . 18126)])
(byte-code "\300\301\302\303#\300\301\304\305#\300\207" [function-put soap-namespace-name side-effect-free t gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" soap-namespace-name] 5 "\n\n(fn CL-DO CL-X)"]] 5)
#@80 compiler-macro for inlining `soap-namespace-elements'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-namespace-elements--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-namespace-elements (progn (or (soap-namespace-p cl-x) (signal 'wrong-type-argument (list 'soap-namespace cl-x))) (aref cl-x 2))) nil] 9 (#$ . 18613)])
(put 'soap-namespace-elements 'compiler-macro 'soap-namespace-elements--cmacro)
#@68 Access slot "elements" of `soap-namespace' struct CL-X.

(fn CL-X)
(defalias 'soap-namespace-elements #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-namespace-tags type-of signal wrong-type-argument soap-namespace 2] 5 (#$ . 19056)])
(byte-code "\300\301\302\303#\300\301\304\305#\306\307\310\"\207" [function-put soap-namespace-elements side-effect-free t gv-expander #[514 "\300\301\302\"\207" [error "%s is a read-only slot" soap-namespace-elements] 5 "\n\n(fn CL-DO CL-X)"] defalias copy-soap-namespace copy-sequence] 5)
#@96 compiler-macro for inlining `make-soap-namespace'.

(fn CL-WHOLE &cl-quote &key NAME ELEMENTS)
(defalias 'make-soap-namespace--cmacro #[385 "\300
\301\"A@\300\302\"\206\303A@\211\203;\211@\304>\203$\211AA\262
\202\305>A@\2032\306\262
\202\307\310@\"\210\202\210\311\312\313\306\306&\207" [plist-member :name :elements (nil (make-hash-table :test 'equal)) (:name :elements :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :elements)" cl--defsubst-expand (name elements) (cl-block make-soap-namespace (record 'soap-namespace name elements))] 12 (#$ . 19612)])
(put 'make-soap-namespace 'compiler-macro 'make-soap-namespace--cmacro)
#@76 Constructor for objects of type `soap-namespace'.

(fn &key NAME ELEMENTS)
(defalias 'make-soap-namespace #[128 "\300
\301\"A@\300\302\"\206\303\304\305\306\"DA@\211\203@\211@\307>\203)\211AA\262
\202\310>A@\2037\303\262
\202\311\312@\"\210\202\210\313\314#\207" [plist-member :name :elements nil make-hash-table :test equal (:name :elements :allow-other-keys) :allow-other-keys error "Keyword argument %s not one of (:name :elements)" record soap-namespace] 7 (#$ . 20307)])
(cl-struct-define 'soap-namespace nil 'cl-structure-object 'record nil '((cl-tag-slot) (name nil :read-only t) (elements (make-hash-table :test 'equal) :read-only t)) 'cl-struct-soap-namespace-tags 'soap-namespace t)
#@201 Store ELEMENT in NS.
Multiple elements with the same name can be stored in a
namespace.  When retrieving the element you can specify a
discriminant predicate to `soap-namespace-get'.

(fn ELEMENT NS)
(defalias 'soap-namespace-put #[514 "\302!>\204\303\304\305D\"\210
\306H\302!	>\204!\303\304\307D\"\210
\310H\311\312\"B#\207" [cl-struct-soap-element-tags cl-struct-soap-namespace-tags type-of signal wrong-type-argument soap-element 1 soap-namespace 2 puthash gethash] 10 (#$ . 21024)])
#@248 Store a link from NAME to TARGET in NS.
TARGET can be either a SOAP-ELEMENT or a string denoting an
element name into another namespace.

If NAME is nil, an element with the same name as TARGET will be
added to the namespace.

(fn NAME TARGET NS)
(defalias 'soap-namespace-put-link #[771 "\203\n\302\232\203M\303!>\203)\303!>\204!\304\305\306D\"\210
\307H\262\202M
:\2035
A\262\202M
;\203M\310\311\"\203J\312\313\"\262\202M
\262\203W\302\232\203^\314\315\316\317\211$\210\320\321\317$\303!	>\204s\304\305\322D\"\210
\313H\323\324\"B#\207" [cl-struct-soap-element-tags cl-struct-soap-namespace-tags #1="" type-of signal wrong-type-argument soap-element 1 string-match "^\\(.*\\):\\(.*\\)$" match-string 2 cl--assertion-failed (and name (not (equal name #1#))) "Cannot determine name for namespace link" nil record soap-namespace-link soap-namespace puthash gethash] 11 (#$ . 21532)])
#@304 Retrieve an element with NAME from the namespace NS.
If multiple elements with the same name exist,
DISCRIMINANT-PREDICATE is used to pick one of them.  This allows
storing elements of different types (like a message type and a
binding) but the same name.

(fn NAME NS &optional DISCRIMINANT-PREDICATE)
(defalias 'soap-namespace-get #[770 ";\204	\301\302!\210\303\304!>\204\305\306\307D\"\210\310H\"
\203D\3112[\211\211\205@\211@
!\2039\312\311\"\210
A\266\202\202(\262
0\207\211G\313U\203N\211@\207\211G\313V\203Z\314\315\"\207\316\207" [cl-struct-soap-namespace-tags cl--assertion-failed (stringp name) gethash type-of signal wrong-type-argument soap-namespace 2 found throw 1 error "Soap-namespace-get(%s): multiple elements, discriminant needed" nil] 9 (#$ . 22460)])
#@71 compiler-macro for inlining `soap-xs-type-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-type-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-type-p (and (memq (type-of cl-x) cl-struct-soap-xs-type-tags) t)) nil] 9 (#$ . 23258)])
(put 'soap-xs-type-p 'compiler-macro 'soap-xs-type-p--cmacro)
#@13 

(fn CL-X)
(defalias 'soap-xs-type-p #[257 "\301
!>\205	\302\207" [cl-struct-soap-xs-type-tags type-of t] 3 (#$ . 23605)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put soap-xs-type-p side-effect-free error-free put soap-xs-type cl-deftype-satisfies] 5)
#@74 compiler-macro for inlining `soap-xs-type-name'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-type-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-type-name (progn (or (soap-xs-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-type cl-x))) (aref cl-x 1))) nil] 9 (#$ . 23888)])
(put 'soap-xs-type-name 'compiler-macro 'soap-xs-type-name--cmacro)
#@62 Access slot "name" of `soap-xs-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-type-name #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-type-tags type-of signal wrong-type-argument soap-xs-type 1] 5 (#$ . 24297)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-type-name side-effect-free t] 4)
#@83 compiler-macro for inlining `soap-xs-type-namespace-tag'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-type-namespace-tag--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-type-namespace-tag (progn (or (soap-xs-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-type cl-x))) (aref cl-x 2))) nil] 9 (#$ . 24640)])
(put 'soap-xs-type-namespace-tag 'compiler-macro 'soap-xs-type-namespace-tag--cmacro)
#@71 Access slot "namespace-tag" of `soap-xs-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-type-namespace-tag #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-type-tags type-of signal wrong-type-argument soap-xs-type 2] 5 (#$ . 25094)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-type-namespace-tag side-effect-free t] 4)
#@72 compiler-macro for inlining `soap-xs-type-id'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-type-id--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-type-id (progn (or (soap-xs-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-type cl-x))) (aref cl-x 3))) nil] 9 (#$ . 25464)])
(put 'soap-xs-type-id 'compiler-macro 'soap-xs-type-id--cmacro)
#@60 Access slot "id" of `soap-xs-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-type-id #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-type-tags type-of signal wrong-type-argument soap-xs-type 3] 5 (#$ . 25863)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-type-id side-effect-free t] 4)
#@80 compiler-macro for inlining `soap-xs-type-attributes'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-type-attributes--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-type-attributes (progn (or (soap-xs-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-type cl-x))) (aref cl-x 4))) nil] 9 (#$ . 26200)])
(put 'soap-xs-type-attributes 'compiler-macro 'soap-xs-type-attributes--cmacro)
#@68 Access slot "attributes" of `soap-xs-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-type-attributes #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-type-tags type-of signal wrong-type-argument soap-xs-type 4] 5 (#$ . 26639)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-type-attributes side-effect-free t] 4)
#@86 compiler-macro for inlining `soap-xs-type-attribute-groups'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-type-attribute-groups--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-type-attribute-groups (progn (or (soap-xs-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-type cl-x))) (aref cl-x 5))) nil] 9 (#$ . 27000)])
(put 'soap-xs-type-attribute-groups 'compiler-macro 'soap-xs-type-attribute-groups--cmacro)
#@74 Access slot "attribute-groups" of `soap-xs-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-type-attribute-groups #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-type-tags type-of signal wrong-type-argument soap-xs-type 5] 5 (#$ . 27469)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put soap-xs-type-attribute-groups side-effect-free t defalias copy-soap-xs-type copy-sequence] 4)
#@130 compiler-macro for inlining `make-soap-xs-type'.

(fn CL-WHOLE &cl-quote &key NAME NAMESPACE-TAG ID ATTRIBUTES ATTRIBUTE-GROUPS)
(defalias 'make-soap-xs-type--cmacro #[385 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\211\203J\211@\306>\2032\211AA\262
\202\307>A@\203A\310\262
\202\311\312@\"\210\202\210\313\314\315\310\n\310\n\n\n\n\n&\n\207" [plist-member :name :namespace-tag :id :attributes :attribute-groups (:name :namespace-tag :id :attributes :attribute-groups :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag :id :attributes :attribute-groups)" cl--defsubst-expand (name namespace-tag id attributes attribute-groups) (cl-block make-soap-xs-type (record 'soap-xs-type name namespace-tag id attributes attribute-groups))] 18 (#$ . 27900)])
(put 'make-soap-xs-type 'compiler-macro 'make-soap-xs-type--cmacro)
#@110 Constructor for objects of type `soap-xs-type'.

(fn &key NAME NAMESPACE-TAG ID ATTRIBUTES ATTRIBUTE-GROUPS)
(defalias 'make-soap-xs-type #[128 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\211\203J\211@\306>\2032\211AA\262
\202\307>A@\203A\310\262
\202\311\312@\"\210\202\210\313\314&\207" [plist-member :name :namespace-tag :id :attributes :attribute-groups (:name :namespace-tag :id :attributes :attribute-groups :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag :id :attributes :attribute-groups)" record soap-xs-type] 13 (#$ . 28815)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put make-soap-xs-type side-effect-free t cl-struct-define soap-xs-type nil soap-element record ((cl-tag-slot) (name nil) (namespace-tag nil) (id) (attributes) (attribute-groups)) cl-struct-soap-xs-type-tags] 11)
#@77 compiler-macro for inlining `soap-xs-basic-type-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-basic-type-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-basic-type-p (and (memq (type-of cl-x) cl-struct-soap-xs-basic-type-tags) t)) nil] 9 (#$ . 29757)])
(put 'soap-xs-basic-type-p 'compiler-macro 'soap-xs-basic-type-p--cmacro)
#@13 

(fn CL-X)
(defalias 'soap-xs-basic-type-p #[257 "\301
!>\205	\302\207" [cl-struct-soap-xs-basic-type-tags type-of t] 3 (#$ . 30140)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put soap-xs-basic-type-p side-effect-free error-free put soap-xs-basic-type cl-deftype-satisfies] 5)
#@80 compiler-macro for inlining `soap-xs-basic-type-name'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-basic-type-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-basic-type-name (progn (or (soap-xs-basic-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-basic-type cl-x))) (aref cl-x 1))) nil] 9 (#$ . 30447)])
(put 'soap-xs-basic-type-name 'compiler-macro 'soap-xs-basic-type-name--cmacro)
#@68 Access slot "name" of `soap-xs-basic-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-basic-type-name #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-basic-type-tags type-of signal wrong-type-argument soap-xs-basic-type 1] 5 (#$ . 30898)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-basic-type-name side-effect-free t] 4)
#@89 compiler-macro for inlining `soap-xs-basic-type-namespace-tag'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-basic-type-namespace-tag--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-basic-type-namespace-tag (progn (or (soap-xs-basic-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-basic-type cl-x))) (aref cl-x 2))) nil] 9 (#$ . 31271)])
(put 'soap-xs-basic-type-namespace-tag 'compiler-macro 'soap-xs-basic-type-namespace-tag--cmacro)
#@77 Access slot "namespace-tag" of `soap-xs-basic-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-basic-type-namespace-tag #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-basic-type-tags type-of signal wrong-type-argument soap-xs-basic-type 2] 5 (#$ . 31767)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-basic-type-namespace-tag side-effect-free t] 4)
#@78 compiler-macro for inlining `soap-xs-basic-type-id'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-basic-type-id--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-basic-type-id (progn (or (soap-xs-basic-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-basic-type cl-x))) (aref cl-x 3))) nil] 9 (#$ . 32167)])
(put 'soap-xs-basic-type-id 'compiler-macro 'soap-xs-basic-type-id--cmacro)
#@66 Access slot "id" of `soap-xs-basic-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-basic-type-id #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-basic-type-tags type-of signal wrong-type-argument soap-xs-basic-type 3] 5 (#$ . 32608)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-basic-type-id side-effect-free t] 4)
#@86 compiler-macro for inlining `soap-xs-basic-type-attributes'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-basic-type-attributes--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-basic-type-attributes (progn (or (soap-xs-basic-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-basic-type cl-x))) (aref cl-x 4))) nil] 9 (#$ . 32975)])
(put 'soap-xs-basic-type-attributes 'compiler-macro 'soap-xs-basic-type-attributes--cmacro)
#@74 Access slot "attributes" of `soap-xs-basic-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-basic-type-attributes #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-basic-type-tags type-of signal wrong-type-argument soap-xs-basic-type 4] 5 (#$ . 33456)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-basic-type-attributes side-effect-free t] 4)
#@92 compiler-macro for inlining `soap-xs-basic-type-attribute-groups'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-basic-type-attribute-groups--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-basic-type-attribute-groups (progn (or (soap-xs-basic-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-basic-type cl-x))) (aref cl-x 5))) nil] 9 (#$ . 33847)])
(put 'soap-xs-basic-type-attribute-groups 'compiler-macro 'soap-xs-basic-type-attribute-groups--cmacro)
#@80 Access slot "attribute-groups" of `soap-xs-basic-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-basic-type-attribute-groups #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-basic-type-tags type-of signal wrong-type-argument soap-xs-basic-type 5] 5 (#$ . 34358)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-basic-type-attribute-groups side-effect-free t] 4)
#@80 compiler-macro for inlining `soap-xs-basic-type-kind'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-basic-type-kind--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-basic-type-kind (progn (or (soap-xs-basic-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-basic-type cl-x))) (aref cl-x 6))) nil] 9 (#$ . 34767)])
(put 'soap-xs-basic-type-kind 'compiler-macro 'soap-xs-basic-type-kind--cmacro)
#@68 Access slot "kind" of `soap-xs-basic-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-basic-type-kind #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-basic-type-tags type-of signal wrong-type-argument soap-xs-basic-type 6] 5 (#$ . 35218)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put soap-xs-basic-type-kind side-effect-free t defalias copy-soap-xs-basic-type copy-sequence] 4)
#@141 compiler-macro for inlining `make-soap-xs-basic-type'.

(fn CL-WHOLE &cl-quote &key NAME NAMESPACE-TAG ID ATTRIBUTES ATTRIBUTE-GROUPS KIND)
(defalias 'make-soap-xs-basic-type--cmacro #[385 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\300\306\"A@\211\203R\211@\307>\203:\211AA\262
\202'\310>A@\203I\311\262
\202'\312\313@\"\210\202'\210\314\315\316\311\311&\207" [plist-member :name :namespace-tag :id :attributes :attribute-groups :kind (:name :namespace-tag :id :attributes :attribute-groups :kind :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag :id :attributes :attribute-groups :kind)" cl--defsubst-expand (name namespace-tag id attributes attribute-groups kind) (cl-block make-soap-xs-basic-type (record 'soap-xs-basic-type name namespace-tag id attributes attribute-groups kind))] 20 (#$ . 35649)])
(put 'make-soap-xs-basic-type 'compiler-macro 'make-soap-xs-basic-type--cmacro)
#@121 Constructor for objects of type `soap-xs-basic-type'.

(fn &key NAME NAMESPACE-TAG ID ATTRIBUTES ATTRIBUTE-GROUPS KIND)
(defalias 'make-soap-xs-basic-type #[128 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\300\306\"A@\211\203R\211@\307>\203:\211AA\262
\202'\310>A@\203I\311\262
\202'\312\313@\"\210\202'\210\314\315&\207" [plist-member :name :namespace-tag :id :attributes :attribute-groups :kind (:name :namespace-tag :id :attributes :attribute-groups :kind :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag :id :attributes :attribute-groups :kind)" record soap-xs-basic-type] 15 (#$ . 36643)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put make-soap-xs-basic-type side-effect-free t cl-struct-define soap-xs-basic-type nil soap-xs-type record ((cl-tag-slot) (name nil) (namespace-tag nil) (id nil) (attributes nil) (attribute-groups nil) (kind)) cl-struct-soap-xs-basic-type-tags] 11)
#@158 Construct NAMESPACE-NAME containing the XMLSchema basic types.
An optional NAMESPACE-TAG can also be specified.

(fn NAMESPACE-NAME &optional NAMESPACE-TAG)
(defalias 'soap-make-xs-basic-types #[513 "\300\301\"\302\211\203#\211@\303\304\301\305\306\307!&\"\210
A\266\202\202\210\207" [make-soap-namespace :name ("string" "language" "ID" "IDREF" "dateTime" "time" "date" "boolean" "gYearMonth" "gYear" "gMonthDay" "gDay" "gMonth" "long" "short" "int" "integer" "nonNegativeInteger" "unsignedLong" "unsignedShort" "unsignedInt" "decimal" "duration" "byte" "unsignedByte" "float" "double" "base64Binary" "anyType" "anyURI" "QName" "Array" "byte[]") soap-namespace-put make-soap-xs-basic-type :namespace-tag :kind intern] 14 (#$ . 37681)])
#@296 Encode the XML attributes for VALUE according to TYPE.
The xsi:type and an optional xsi:nil attributes are added.  The
attributes are inserted in the current buffer at the current
position.

This is a specialization of `soap-encode-attributes' for
`soap-xs-basic-type' objects.

(fn VALUE TYPE)
(defalias 'soap-encode-xs-basic-type-attributes #[514 "\301
!\302!>\204\303\304\305D\"\210
\306H\211\307=\203J;\203)\310\262\311\262
\202J\250\2037\312\262\313\262
\202J\314>\203F\315\262\316\262
\202J\317\320!\210\321\322\261\210\206W\211\316=?\205]\323c\207" [cl-struct-soap-xs-basic-type-tags soap-element-fq-name type-of signal wrong-type-argument soap-xs-basic-type 6 anyType "xsd:string" string "xsd:int" int (t nil) "xsd:boolean" boolean error "Cannot classify anyType value" " xsi:type=\"" "\"" " xsi:nil=\"true\""] 7 (#$ . 38435)])
#@205 Encode the VALUE according to TYPE.
The data is inserted in the current buffer at the current
position.

This is a specialization of `soap-encode-value' for
`soap-xs-basic-type' objects.

(fn VALUE TYPE)
(defalias 'soap-encode-xs-basic-type #[514 "\301
!>\204\302\303\304D\"\210\211\305H<\203\306!@\202
\307=\203K\211;\2030\310\262\202K\211\250\203;\311\262\202K\211\312>\203G\313\262\202K\314\315!\210\211\204U
\313=\205\"

\316\267\202
\211;\204e\314\317\"\210\320
!\202
\211:\203\250\321\322\267\202\227\323\202\240\324\202\240\325\202\240\326\202\240\327\202\240\330\202\240\331\202\240\332\202\240\314\333\334#\205\240\335\336P\337#\202
\211;\203\270\340
\"\210\320
!\202
\314\341!\202
\211\342>\204\310\314\343!\210\211\203\320\344\202
\345\202
\211\250\204\335\314\346!\210
\347>\203\355\211\350W\203\355\314\351!\210\352
!\202
\211\247\204\374\314\353!\210\352
!\202
\211;\204
\314\354!\210\355
!\202
\314\356\357!#\360
\"\210\211c\262
\207" [cl-struct-soap-xs-basic-type-tags type-of signal wrong-type-argument soap-xs-basic-type 6 last anyType string int (t nil) boolean error "Cannot classify anyType value" #s(hash-table size 29 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (string 91 anyURI 91 QName 91 ID 91 IDREF 91 language 91 dateTime 107 time 107 date 107 gYearMonth 107 gYear 107 gMonthDay 107 gDay 107 gMonth 107 boolean 190 long 212 short 212 int 212 integer 212 byte 212 unsignedInt 212 unsignedLong 212 unsignedShort 212 nonNegativeInteger 212 decimal 212 duration 212 float 243 double 243 base64Binary 258)) "Not a string value: %s" url-insert-entities-in-string format-time-string #s(hash-table size 8 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (dateTime 119 time 123 date 127 gYearMonth 131 gYear 135 gMonthDay 139 gDay 143 gMonth 147)) "%Y-%m-%dT%H:%M:%S" "%H:%M:%S" "%Y-%m-%d" "%Y-%m" "%Y" "--%m-%d" "---%d" "--%m" "cl-ecase failed: %s, %s" (dateTime time date gYearMonth gYear gMonthDay gDay gMonth) nil "Z" t soap-decode-date-time "Invalid date-time format" (t nil) "Not a boolean value" "true" "false" "Not an integer value" (unsignedInt unsignedLong unsignedShort nonNegativeInteger) 0 "Not a positive integer" number-to-string "Not a number" "Not a string value for base64Binary" base64-encode-string "Don't know how to encode %s for type %s" soap-element-fq-name soap-validate-xs-basic-type] 9 (#$ . 39301)])
#@2841 Decode DATE-TIME-STRING as DATATYPE.
DATE-TIME-STRING should be in ISO 8601 basic or extended format.
DATATYPE can be omitted, or one of the symbols dateTime, time,
date, gYearMonth, gYear, gMonthDay, gDay, or gMonth.  If Emacs is
a version that supports fractional seconds, DATATYPE can also be
dateTime-subsecond, or time-subsecond.  On older versions of
Emacs (prior to 27.1), which do not support fractional seconds,
leaving DATATYPE nil means that subseconds in DATE-TIME-STRING
will be ignored.

Return a list in a format identical or similar to that returned
by `decode-time'.  The returned format is always compatible with
`encode-time'.  If DATATYPE is omitted or nil, this function will
return a list that has exactly the same format as that returned
by `decode-time'.

Note that on versions of Emacs that predate support for
fractional seconds, `encode-time' will not notice the SUBSECOND
field so it must be handled specially.

The formats returned by this function are as follows, where _
means "should be ignored":

 DATATYPE   | Return format
------------+----------------------------------------------------------------
 nil        | (SECOND MINUTE HOUR DAY MONTH YEAR DOW       DST        UTCOFF)
 dateTime   | (SECOND MINUTE HOUR DAY MONTH YEAR SUBSECOND dateTime   UTCOFF)
 time       | (SECOND MINUTE HOUR _   _     _    SUBSECOND time       _)
 date       | (_      _      _    DAY MONTH YEAR _         date       _)
 gYearMonth | (_      _      _    _   MONTH YEAR _         gYearMonth _)
 gYear      | (_      _      _    _   _     YEAR _         gYear      _)
 gMonthDay  | (_      _      _    DAY MONTH _    _         gMonthDay  _)
 gDay       | (_      _      _    DAY _     _    _         gDay       _)
 gMonth     | (_      _      _    _   MONTH _    _         gMonth     _)

When DATATYPE is dateTime or time, the DOW (day-of-week) field is
replaced with SUBSECOND, a float representing the fractional
seconds, and the DST (daylight savings time) field is replaced
with DATATYPE, a symbol representing the XSD primitive datatype.
This symbol can be used to determine which fields apply and which
do not, when it is not already clear from context.  For example a
datatype of `time' means the year, month, day and time zone
fields should be ignored.

New code that depends on Emacs 27.1 or newer anyway, and that
wants dateTime or time but with the first argument with subsecond
resolution, i.e., (TICKS . HZ), can set DATATYPE to
dateTime-subsecond or time-subsecond respectively.  This function
throws an error if dateTime-subsecond or time-subsecond is
specified when Emacs does not support subsecond resolution.

This function throws an error if DATE-TIME-STRING represents a
leap second, since the XML Schema 1.1 standard does not support
representing leap seconds.

(fn DATE-TIME-STRING &optional DATATYPE)
(defalias 'soap-decode-date-time #[513 "\3001\301\302\211\303#??0\202\210\302\302\304>\2035
\203)\305\306\307\310\311!#!\202>\312\313\314\311!\"!\202>\204=\315\202>\211\316NA@\317
\"\210\320\321\"\320\322\"\320\323	\"\320\324\n\"\320\325\"\320\326\f\"\320\327
\"\320\330\"\302\320\331\"\320\332\"\320\333\"\320\334\"\f\203\217\335\202\220\321\262
\203\241\f\336
!_\202\242\337\262\f\n\203\260\336!\202\261\321\262	\203\277\336\n!\202\300\321\262\n\203\316\336	!\202\317\340\262	\203\335\336!\202\336\340\262\203
\205
\203
\341\342\310#\343\332G\"\211\336\n!_\336!\\\211B\266\203\202
\321B\262\203
\336!\202
\340\262\203;
\2042
\2042
\344\345!\210\346\336!!\202<
\347\262\205C
\303\262\350\232\203O
\335\202P
\321\262
\203\\
\336!\202]
\340\262\211\203i
\336
!\202j
\340\262
\203z
\351\340#_\202{
\340\262\340V\203\347
\n\321Y\203\347
\n\334X\203\347
	\321Y\203\347
	\352

\"X\203\347
\340Y\203\347
\353X\203\347
\340Y\203\347
\354X\203\347
\340Y\203\347
\354X\203\347

\340Y\203\347

\353X\203\347
\211\340Y\203\347
\211\354X\204\355
\312\355\"\210\203\356>\203\376
\202\n\f\f\257	\207\357\360\203\202!\n\f\302\211\257	\"\203=\301
\302\303#\207\301
!\207" [(wrong-number-of-arguments) decode-time nil t (dateTime-subsecond time-subsecond) intern replace-regexp-in-string "-subsecond" "" symbol-name error format "This Emacs version does not support %s" dateTime rng-xsd-convert string-match match-string 1 2 3 4 5 6 7 8 9 10 11 12 -1 string-to-number 1970 0 string-replace "." expt message "soap-decode-date-time: Discarding fractional seconds" float 0.0 "-" rng-xsd-time-to-seconds rng-xsd-days-in-month 23 59 "Invalid or unsupported time: %s" (dateTime-subsecond time-subsecond) apply encode-time] 30 (#$ . 41753)])
#@254 Use TYPE, a `soap-xs-basic-type', to decode the contents of NODE.
A LISP value is returned based on the contents of NODE and the
type-info stored in TYPE.

This is a specialization of `soap-decode-type' for
`soap-xs-basic-type' objects.

(fn TYPE NODE)
(defalias 'soap-decode-xs-basic-type #[514 "\211\211AA\262
\302!>\204\303\304\305D\"\210\306H\211A@\262
\307\211\203R\211@\310
@!
A
\310\311!\232\203;\312
	\"\262
\310\313!\232\203I\211\227\314\230\262\266
A\266\202\202!\210\211\204b\315\206^\316C@\"\210\205\225\317\267\202\214@\207@\207\320@!\207@\227\314\230\207\321@!\207\322!\207\323!\207\324\325\326#\205\225\307\207" [cl-struct-soap-xs-basic-type-tags soap-current-wsdl type-of signal wrong-type-argument soap-xs-basic-type 6 nil soap-l2fq "xsi:type" soap-wsdl-get "xsi:nil" "true" soap-validate-xs-basic-type "" #s(hash-table size 31 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (string 108 anyURI 108 QName 108 ID 108 IDREF 108 language 108 dateTime 111 time 111 date 111 gYearMonth 111 gYear 111 gMonthDay 111 gDay 111 gMonth 111 long 114 short 114 int 114 integer 114 unsignedInt 114 unsignedLong 114 unsignedShort 114 nonNegativeInteger 114 decimal 114 byte 114 float 114 double 114 duration 114 boolean 119 base64Binary 125 anyType 130 Array 135)) string-to-number base64-decode-string soap-decode-any-type soap-decode-array error "cl-ecase failed: %s, %s" (language IDREF ID QName anyURI string gMonth gDay gMonthDay gYear gYearMonth date time dateTime duration double float byte decimal nonNegativeInteger unsignedShort unsignedLong unsignedInt integer int short long boolean base64Binary anyType Array)] 14 (#$ . 46501)])
(byte-code "\300\301\302\303\304\305\211\211\211\211\211&!\304=\203\302\202\306\"\210\301\303\304\305\211\211\211\211\211&!\307
\310\311#\210\307
\312\313#\210\307
\314\315#\210\207" [defalias soap-type-of type-of record soap-xs-basic-type nil #[257 "\300
!\203\n\211\301H\207\302
!\207" [vectorp 0 type-of] 3 "Return the type of ELEMENT.\n\n(fn ELEMENT)"] put soap-attribute-encoder soap-encode-xs-basic-type-attributes soap-encoder soap-encode-xs-basic-type soap-decoder soap-decode-xs-basic-type] 11)
#@74 compiler-macro for inlining `soap-xs-element-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-element-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-element-p (and (memq (type-of cl-x) cl-struct-soap-xs-element-tags) t)) nil] 9 (#$ . 48713)])
(put 'soap-xs-element-p 'compiler-macro 'soap-xs-element-p--cmacro)
#@13 

(fn CL-X)
(defalias 'soap-xs-element-p #[257 "\301
!>\205	\302\207" [cl-struct-soap-xs-element-tags type-of t] 3 (#$ . 49078)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put soap-xs-element-p side-effect-free error-free put soap-xs-element cl-deftype-satisfies] 5)
#@77 compiler-macro for inlining `soap-xs-element-name'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-element-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-element-name (progn (or (soap-xs-element-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-element cl-x))) (aref cl-x 1))) nil] 9 (#$ . 49373)])
(put 'soap-xs-element-name 'compiler-macro 'soap-xs-element-name--cmacro)
#@65 Access slot "name" of `soap-xs-element' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-element-name #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-element-tags type-of signal wrong-type-argument soap-xs-element 1] 5 (#$ . 49803)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-element-name side-effect-free t] 4)
#@86 compiler-macro for inlining `soap-xs-element-namespace-tag'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-element-namespace-tag--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-element-namespace-tag (progn (or (soap-xs-element-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-element cl-x))) (aref cl-x 2))) nil] 9 (#$ . 50161)])
(put 'soap-xs-element-namespace-tag 'compiler-macro 'soap-xs-element-namespace-tag--cmacro)
#@74 Access slot "namespace-tag" of `soap-xs-element' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-element-namespace-tag #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-element-tags type-of signal wrong-type-argument soap-xs-element 2] 5 (#$ . 50636)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-element-namespace-tag side-effect-free t] 4)
#@75 compiler-macro for inlining `soap-xs-element-id'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-element-id--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-element-id (progn (or (soap-xs-element-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-element cl-x))) (aref cl-x 3))) nil] 9 (#$ . 51021)])
(put 'soap-xs-element-id 'compiler-macro 'soap-xs-element-id--cmacro)
#@63 Access slot "id" of `soap-xs-element' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-element-id #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-element-tags type-of signal wrong-type-argument soap-xs-element 3] 5 (#$ . 51441)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-element-id side-effect-free t] 4)
#@78 compiler-macro for inlining `soap-xs-element-type^'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-element-type^--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-element-type^ (progn (or (soap-xs-element-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-element cl-x))) (aref cl-x 4))) nil] 9 (#$ . 51793)])
(put 'soap-xs-element-type^ 'compiler-macro 'soap-xs-element-type^--cmacro)
#@66 Access slot "type^" of `soap-xs-element' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-element-type^ #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-element-tags type-of signal wrong-type-argument soap-xs-element 4] 5 (#$ . 52228)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-element-type^ side-effect-free t] 4)
#@82 compiler-macro for inlining `soap-xs-element-optional?'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-element-optional\?--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-element-optional\? (progn (or (soap-xs-element-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-element cl-x))) (aref cl-x 5))) nil] 9 (#$ . 52589)])
(put 'soap-xs-element-optional\? 'compiler-macro 'soap-xs-element-optional\?--cmacro)
#@70 Access slot "optional?" of `soap-xs-element' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-element-optional\? #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-element-tags type-of signal wrong-type-argument soap-xs-element 5] 5 (#$ . 53048)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-element-optional\? side-effect-free t] 4)
#@82 compiler-macro for inlining `soap-xs-element-multiple?'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-element-multiple\?--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-element-multiple\? (progn (or (soap-xs-element-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-element cl-x))) (aref cl-x 6))) nil] 9 (#$ . 53423)])
(put 'soap-xs-element-multiple\? 'compiler-macro 'soap-xs-element-multiple\?--cmacro)
#@70 Access slot "multiple?" of `soap-xs-element' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-element-multiple\? #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-element-tags type-of signal wrong-type-argument soap-xs-element 6] 5 (#$ . 53882)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-element-multiple\? side-effect-free t] 4)
#@82 compiler-macro for inlining `soap-xs-element-reference'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-element-reference--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-element-reference (progn (or (soap-xs-element-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-element cl-x))) (aref cl-x 7))) nil] 9 (#$ . 54257)])
(put 'soap-xs-element-reference 'compiler-macro 'soap-xs-element-reference--cmacro)
#@70 Access slot "reference" of `soap-xs-element' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-element-reference #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-element-tags type-of signal wrong-type-argument soap-xs-element 7] 5 (#$ . 54712)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-element-reference side-effect-free t] 4)
#@91 compiler-macro for inlining `soap-xs-element-substitution-group'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-element-substitution-group--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-element-substitution-group (progn (or (soap-xs-element-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-element cl-x))) (aref cl-x 8))) nil] 9 (#$ . 55085)])
(put 'soap-xs-element-substitution-group 'compiler-macro 'soap-xs-element-substitution-group--cmacro)
#@79 Access slot "substitution-group" of `soap-xs-element' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-element-substitution-group #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-element-tags type-of signal wrong-type-argument soap-xs-element 8] 5 (#$ . 55585)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-element-substitution-group side-effect-free t] 4)
#@85 compiler-macro for inlining `soap-xs-element-alternatives'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-element-alternatives--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-element-alternatives (progn (or (soap-xs-element-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-element cl-x))) (aref cl-x 9))) nil] 9 (#$ . 55985)])
(put 'soap-xs-element-alternatives 'compiler-macro 'soap-xs-element-alternatives--cmacro)
#@73 Access slot "alternatives" of `soap-xs-element' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-element-alternatives #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-element-tags type-of signal wrong-type-argument soap-xs-element 9] 5 (#$ . 56455)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-element-alternatives side-effect-free t] 4)
#@81 compiler-macro for inlining `soap-xs-element-is-group'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-element-is-group--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-element-is-group (progn (or (soap-xs-element-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-element cl-x))) (aref cl-x 10))) nil] 9 (#$ . 56837)])
(put 'soap-xs-element-is-group 'compiler-macro 'soap-xs-element-is-group--cmacro)
#@69 Access slot "is-group" of `soap-xs-element' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-element-is-group #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-element-tags type-of signal wrong-type-argument soap-xs-element 10] 5 (#$ . 57288)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put soap-xs-element-is-group side-effect-free t defalias copy-soap-xs-element copy-sequence] 4)
#@188 compiler-macro for inlining `make-soap-xs-element'.

(fn CL-WHOLE &cl-quote &key NAME NAMESPACE-TAG ID TYPE^ OPTIONAL\=\? MULTIPLE\=\? REFERENCE SUBSTITUTION-GROUP ALTERNATIVES IS-GROUP)
(defalias 'make-soap-xs-element--cmacro #[385 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\300\306\"A@\300\307\"A@\300\310\"A@\300	\311\"A@\300\n\312\"A@\n\211\203n\211@\313>\203V\211AA\262
\202C\314\f>A@\203e\315\262
\202C\316\317@\"\210\202C\210\320\321\322\315\315&\207" [plist-member :name :namespace-tag :id :type^ :optional\? :multiple\? :reference :substitution-group :alternatives :is-group (:name :namespace-tag :id :type^ :optional\? :multiple\? :reference :substitution-group :alternatives :is-group :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag :id :type^ :optional? :multiple? :reference :substitution-group :alternatives :is-group)" cl--defsubst-expand (name namespace-tag id type^ optional\? multiple\? reference substitution-group alternatives is-group) (cl-block make-soap-xs-element (record 'soap-xs-element name namespace-tag id type^ optional\? multiple\? reference substitution-group alternatives is-group))] 28 (#$ . 57714)])
(put 'make-soap-xs-element 'compiler-macro 'make-soap-xs-element--cmacro)
#@168 Constructor for objects of type `soap-xs-element'.

(fn &key NAME NAMESPACE-TAG ID TYPE^ OPTIONAL\=\? MULTIPLE\=\? REFERENCE SUBSTITUTION-GROUP ALTERNATIVES IS-GROUP)
(defalias 'make-soap-xs-element #[128 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\300\306\"A@\300\307\"A@\300\310\"A@\300	\311\"A@\300\n\312\"A@\n\211\203n\211@\313>\203V\211AA\262
\202C\314\f>A@\203e\315\262
\202C\316\317@\"\210\202C\210\320\321&\207" [plist-member :name :namespace-tag :id :type^ :optional\? :multiple\? :reference :substitution-group :alternatives :is-group (:name :namespace-tag :id :type^ :optional\? :multiple\? :reference :substitution-group :alternatives :is-group :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag :id :type^ :optional? :multiple? :reference :substitution-group :alternatives :is-group)" record soap-xs-element] 23 (#$ . 59047)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put make-soap-xs-element side-effect-free t cl-struct-define soap-xs-element nil soap-element record ((cl-tag-slot) (name nil) (namespace-tag nil) (id) (type^) (optional\?) (multiple\?) (reference) (substitution-group) (alternatives) (is-group)) cl-struct-soap-xs-element-tags] 11)
#@166 Retrieve the type of ELEMENT.
This is normally stored in the TYPE^ slot, but if this element
contains a reference, retrieve the type of the reference.

(fn ELEMENT)
(defalias 'soap-xs-element-type #[257 "\301
!>\204\302\303\304D\"\210\211\305H\203*\306\301!>\204%\302\303\304D\"\210
\305H!\207\301
!>\2049\302\303\304D\"\210\211\307H\207" [cl-struct-soap-xs-element-tags type-of signal wrong-type-argument soap-xs-element 7 soap-xs-element-type 4] 6 (#$ . 60374)])
#@60 Return t if NODE specifies an optional element.

(fn NODE)
(defalias 'soap-node-optional #[257 "\300
\301\"\302\232\206\300
\303\"\211\205\211\304\232\262
\207" [xml-get-attribute-or-nil nillable "true" minOccurs "0"] 4 (#$ . 60857)])
#@56 Return t if NODE permits multiple elements.

(fn NODE)
(defalias 'soap-node-multiple #[257 "\300
\301\"\211\205\f\211\302\232?\207" [xml-get-attribute-or-nil maxOccurs "1"] 4 (#$ . 61102)])
#@53 Construct a `soap-xs-element' from NODE.

(fn NODE)
(defalias 'soap-xs-parse-element #[257 "\301
\302\"\301\303\"\301\304\"\305!\306!\301\307\"\301\310\"\311\211@\262
!\211\312>\2042\313\314\211C\315$\210\203=\316\317\"\262\203G\316\317\"\262
\203Q\316\317\"\262\204\205\204\205\320	\321\"\211\203l\322
@!\262\210\202\205\320\n\323\"\211\203\200\324
@!\262\266\202\205\325\326!\266\327\330	\n\n\n\n\n\n\315\331=&\207" [soap-target-xmlns xml-get-attribute-or-nil name id type soap-node-optional soap-node-multiple ref substitutionGroup soap-l2wk #1=(xsd:element xsd:group) cl--assertion-failed (memq node-name '#1#) nil soap-l2fq tns soap-xml-get-children1 xsd:simpleType soap-xs-parse-simple-type xsd:complexType soap-xs-parse-complex-type error "soap-xs-parse-element: Missing type or ref" record soap-xs-element xsd:group] 22 (#$ . 61299)])
#@213 Replace names in ELEMENT with the referenced objects in the WSDL.
This is a specialization of `soap-resolve-references' for
`soap-xs-element' objects.

See also `soap-wsdl-resolve-references'.

(fn ELEMENT WSDL)
(defalias 'soap-resolve-references-for-xs-element #[514 "\303!>\204\304\305\306D\"\210
\307H\211\2037\310
\311!\"@\211\2036\303!>\2041\304\305\306D\"\210\307I\210\210\210\303!	>\204G\304\305\312D\"\210
\313H\314
!\203l\303!	>\204_\304\305\312D\"\210\313\315\316#I\266\202z\303
!\n>\203y\317
\"\210\210\303!	>\204\211\304\305\312D\"\210
\320H\314
!\203\277\303!	>\204\241\304\305\312D\"\210\321H\204\277\303!	>\204\266\304\305\312D\"\210\320\315\322#I\210\210\303!	>\204\317\304\305\312D\"\210
\323H\314
!\205\n
\315
\"\211\203\372\303
!	>\204\357\304\305\312D\"\210\211\324\324HBI\202
\325C\326\327\330\331#\332#\266\202\262
\207" [cl-struct-soap-element-tags cl-struct-soap-xs-element-tags cl-struct-soap-xs-type-tags type-of signal wrong-type-argument soap-element 2 rassoc soap-wsdl-alias-table soap-xs-element 4 soap-name-p soap-wsdl-get soap-xs-type-p soap-resolve-references 7 10 soap-xs-element-p 8 9 "No target found for substitution-group" display-warning soap-client apply format :warning] 12 (#$ . 62198)])
#@203 Encode the XML attributes for VALUE according to ELEMENT.
Currently no attributes are needed.

This is a specialization of `soap-encode-attributes' for
`soap-xs-basic-type' objects.

(fn VALUE ELEMENT)
(defalias 'soap-encode-xs-element-attributes #[514 "\300\207" [nil] 3 (#$ . 63492)])
#@85 Return t if VALUE should be encoded for ELEMENT, nil otherwise.

(fn VALUE ELEMENT)
(defalias 'soap-should-encode-value-for-xs-element #[514 "
\203\302\207\303
!\304
!>\205%\304
!>\204 \305\306\307D\"\210\211\310H\311=\262
\206d\303
!\3122^\304
!	>\204@\305\306\313D\"\210\211\314H\211\205[\211@\315
!\203T\316\312\302\"\210
A\266\202\202C\262
0\262
\206d\317\207" [cl-struct-soap-xs-basic-type-tags cl-struct-soap-xs-type-tags t soap-xs-element-type type-of signal wrong-type-argument soap-xs-basic-type 6 boolean found soap-xs-type 4 soap-xs-attribute-default throw nil] 8 (#$ . 63785)])
#@47 Return t if TYPE defines an ARRAY.

(fn TYPE)
(defalias 'soap-type-is-array\? #[257 "\300
!\205\301
!\302=\207" [soap-xs-complex-type-p soap-xs-complex-type-indicator array] 3 (#$ . 64396)])
#@257 A list of namespace tags used during encoding a message.
This list is populated by `soap-encode-value' and used by
`soap-create-envelope' to add aliases for these namespace to the
XML request.

This variable is dynamically bound in `soap-create-envelope'.
(defvar soap-encoded-namespaces nil (#$ . 64596))
#@211 Encode the VALUE according to ELEMENT.
The data is inserted in the current buffer at the current
position.

This is a specialization of `soap-encode-value' for
`soap-xs-basic-type' objects.

(fn VALUE ELEMENT)
(defalias 'soap-encode-xs-element #[514 "\304
!\305!\306!>\204\307\310\311D\"\210\312H\203\324\313\"\205\337\314\261\210\315\"\210\204O\306
!	>\203\321\306
!	>\204G\307\310\316D\"\210\211\317H\320=\203\321\321c\210\322
!\203\306\323!\306!>\204j\307\310\311D\"\210
\324H\203\223\306!>\204\307\310\311D\"\210
\324H\211\n\235\203\216\n\266\202\223\211\nB\210\306
!>\204\242\307\310\325D\"\210\211\326\327!I\210\330G

W\203\301\331H\"\210
T\262\202\254\266\202\313\332\"\210\333\334\261\207\335c\207\313\"\205\337\332\"\207" [cl-struct-soap-element-tags cl-struct-soap-xs-basic-type-tags soap-encoded-namespaces cl-struct-soap-xs-element-tags soap-element-fq-name soap-xs-element-type type-of signal wrong-type-argument soap-element 1 soap-should-encode-value-for-xs-element "<" soap-encode-attributes soap-xs-basic-type 6 boolean ">" soap-type-is-array\? copy-soap-xs-element 2 soap-xs-element 4 soap-xs-complex-type-base 0 soap-encode-xs-element soap-encode-value "</" ">\n" "/>\n"] 10 (#$ . 64909)])
#@260 Use ELEMENT, a `soap-xs-element', to decode the contents of NODE.
A LISP value is returned based on the contents of NODE and the
type-info stored in ELEMENT.

This is a specialization of `soap-decode-type' for
`soap-xs-basic-type' objects.

(fn ELEMENT NODE)
(defalias 'soap-decode-xs-element #[514 "\300!\301
\"\207" [soap-xs-element-type soap-decode-type] 6 (#$ . 66185)])
(byte-code "\300\301\302\303\211\211\211\211\211\211\211\211\211&!\304
\305\306#\210\304
\307\310#\210\304
\311\312#\210\304
\313\314#\210\207" [soap-type-of record soap-xs-element nil put soap-resolve-references soap-resolve-references-for-xs-element soap-attribute-encoder soap-encode-xs-element-attributes soap-encoder soap-encode-xs-element soap-decoder soap-decode-xs-element] 13)
#@76 compiler-macro for inlining `soap-xs-attribute-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-attribute-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-attribute-p (and (memq (type-of cl-x) cl-struct-soap-xs-attribute-tags) t)) nil] 9 (#$ . 66955)])
(put 'soap-xs-attribute-p 'compiler-macro 'soap-xs-attribute-p--cmacro)
#@13 

(fn CL-X)
(defalias 'soap-xs-attribute-p #[257 "\301
!>\205	\302\207" [cl-struct-soap-xs-attribute-tags type-of t] 3 (#$ . 67332)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put soap-xs-attribute-p side-effect-free error-free put soap-xs-attribute cl-deftype-satisfies] 5)
#@79 compiler-macro for inlining `soap-xs-attribute-name'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-attribute-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-attribute-name (progn (or (soap-xs-attribute-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-attribute cl-x))) (aref cl-x 1))) nil] 9 (#$ . 67635)])
(put 'soap-xs-attribute-name 'compiler-macro 'soap-xs-attribute-name--cmacro)
#@67 Access slot "name" of `soap-xs-attribute' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-attribute-name #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-attribute-tags type-of signal wrong-type-argument soap-xs-attribute 1] 5 (#$ . 68079)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-attribute-name side-effect-free t] 4)
#@88 compiler-macro for inlining `soap-xs-attribute-namespace-tag'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-attribute-namespace-tag--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-attribute-namespace-tag (progn (or (soap-xs-attribute-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-attribute cl-x))) (aref cl-x 2))) nil] 9 (#$ . 68447)])
(put 'soap-xs-attribute-namespace-tag 'compiler-macro 'soap-xs-attribute-namespace-tag--cmacro)
#@76 Access slot "namespace-tag" of `soap-xs-attribute' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-attribute-namespace-tag #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-attribute-tags type-of signal wrong-type-argument soap-xs-attribute 2] 5 (#$ . 68936)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-attribute-namespace-tag side-effect-free t] 4)
#@79 compiler-macro for inlining `soap-xs-attribute-type'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-attribute-type--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-attribute-type (progn (or (soap-xs-attribute-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-attribute cl-x))) (aref cl-x 3))) nil] 9 (#$ . 69331)])
(put 'soap-xs-attribute-type 'compiler-macro 'soap-xs-attribute-type--cmacro)
#@67 Access slot "type" of `soap-xs-attribute' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-attribute-type #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-attribute-tags type-of signal wrong-type-argument soap-xs-attribute 3] 5 (#$ . 69775)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-attribute-type side-effect-free t] 4)
#@82 compiler-macro for inlining `soap-xs-attribute-default'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-attribute-default--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-attribute-default (progn (or (soap-xs-attribute-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-attribute cl-x))) (aref cl-x 4))) nil] 9 (#$ . 70143)])
(put 'soap-xs-attribute-default 'compiler-macro 'soap-xs-attribute-default--cmacro)
#@70 Access slot "default" of `soap-xs-attribute' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-attribute-default #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-attribute-tags type-of signal wrong-type-argument soap-xs-attribute 4] 5 (#$ . 70602)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-attribute-default side-effect-free t] 4)
#@84 compiler-macro for inlining `soap-xs-attribute-reference'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-attribute-reference--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-attribute-reference (progn (or (soap-xs-attribute-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-attribute cl-x))) (aref cl-x 5))) nil] 9 (#$ . 70979)])
(put 'soap-xs-attribute-reference 'compiler-macro 'soap-xs-attribute-reference--cmacro)
#@72 Access slot "reference" of `soap-xs-attribute' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-attribute-reference #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-attribute-tags type-of signal wrong-type-argument soap-xs-attribute 5] 5 (#$ . 71448)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put soap-xs-attribute-reference side-effect-free t defalias copy-soap-xs-attribute copy-sequence] 4)
#@127 compiler-macro for inlining `make-soap-xs-attribute'.

(fn CL-WHOLE &cl-quote &key NAME NAMESPACE-TAG TYPE DEFAULT REFERENCE)
(defalias 'make-soap-xs-attribute--cmacro #[385 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\211\203J\211@\306>\2032\211AA\262
\202\307>A@\203A\310\262
\202\311\312@\"\210\202\210\313\314\315\310\n\310\n\n\n\n\n&\n\207" [plist-member :name :namespace-tag :type :default :reference (:name :namespace-tag :type :default :reference :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag :type :default :reference)" cl--defsubst-expand (name namespace-tag type default reference) (cl-block make-soap-xs-attribute (record 'soap-xs-attribute name namespace-tag type default reference))] 18 (#$ . 71888)])
(put 'make-soap-xs-attribute 'compiler-macro 'make-soap-xs-attribute--cmacro)
#@107 Constructor for objects of type `soap-xs-attribute'.

(fn &key NAME NAMESPACE-TAG TYPE DEFAULT REFERENCE)
(defalias 'make-soap-xs-attribute #[128 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\211\203J\211@\306>\2032\211AA\262
\202\307>A@\203A\310\262
\202\311\312@\"\210\202\210\313\314&\207" [plist-member :name :namespace-tag :type :default :reference (:name :namespace-tag :type :default :reference :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag :type :default :reference)" record soap-xs-attribute] 13 (#$ . 72785)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put make-soap-xs-attribute side-effect-free t cl-struct-define soap-xs-attribute nil soap-element record ((cl-tag-slot) (name nil) (namespace-tag nil) (type) (default) (reference)) cl-struct-soap-xs-attribute-tags] 11)
#@82 compiler-macro for inlining `soap-xs-attribute-group-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-attribute-group-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-attribute-group-p (and (memq (type-of cl-x) cl-struct-soap-xs-attribute-group-tags) t)) nil] 9 (#$ . 73717)])
(put 'soap-xs-attribute-group-p 'compiler-macro 'soap-xs-attribute-group-p--cmacro)
#@13 

(fn CL-X)
(defalias 'soap-xs-attribute-group-p #[257 "\301
!>\205	\302\207" [cl-struct-soap-xs-attribute-group-tags type-of t] 3 (#$ . 74130)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put soap-xs-attribute-group-p side-effect-free error-free put soap-xs-attribute-group cl-deftype-satisfies] 5)
#@85 compiler-macro for inlining `soap-xs-attribute-group-name'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-attribute-group-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-attribute-group-name (progn (or (soap-xs-attribute-group-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-attribute-group cl-x))) (aref cl-x 1))) nil] 9 (#$ . 74457)])
(put 'soap-xs-attribute-group-name 'compiler-macro 'soap-xs-attribute-group-name--cmacro)
#@73 Access slot "name" of `soap-xs-attribute-group' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-attribute-group-name #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-attribute-group-tags type-of signal wrong-type-argument soap-xs-attribute-group 1] 5 (#$ . 74943)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-attribute-group-name side-effect-free t] 4)
#@94 compiler-macro for inlining `soap-xs-attribute-group-namespace-tag'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-attribute-group-namespace-tag--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-attribute-group-namespace-tag (progn (or (soap-xs-attribute-group-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-attribute-group cl-x))) (aref cl-x 2))) nil] 9 (#$ . 75341)])
(put 'soap-xs-attribute-group-namespace-tag 'compiler-macro 'soap-xs-attribute-group-namespace-tag--cmacro)
#@82 Access slot "namespace-tag" of `soap-xs-attribute-group' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-attribute-group-namespace-tag #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-attribute-group-tags type-of signal wrong-type-argument soap-xs-attribute-group 2] 5 (#$ . 75872)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-attribute-group-namespace-tag side-effect-free t] 4)
#@83 compiler-macro for inlining `soap-xs-attribute-group-id'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-attribute-group-id--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-attribute-group-id (progn (or (soap-xs-attribute-group-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-attribute-group cl-x))) (aref cl-x 3))) nil] 9 (#$ . 76297)])
(put 'soap-xs-attribute-group-id 'compiler-macro 'soap-xs-attribute-group-id--cmacro)
#@71 Access slot "id" of `soap-xs-attribute-group' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-attribute-group-id #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-attribute-group-tags type-of signal wrong-type-argument soap-xs-attribute-group 3] 5 (#$ . 76773)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-attribute-group-id side-effect-free t] 4)
#@91 compiler-macro for inlining `soap-xs-attribute-group-attributes'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-attribute-group-attributes--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-attribute-group-attributes (progn (or (soap-xs-attribute-group-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-attribute-group cl-x))) (aref cl-x 4))) nil] 9 (#$ . 77165)])
(put 'soap-xs-attribute-group-attributes 'compiler-macro 'soap-xs-attribute-group-attributes--cmacro)
#@79 Access slot "attributes" of `soap-xs-attribute-group' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-attribute-group-attributes #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-attribute-group-tags type-of signal wrong-type-argument soap-xs-attribute-group 4] 5 (#$ . 77681)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-attribute-group-attributes side-effect-free t] 4)
#@97 compiler-macro for inlining `soap-xs-attribute-group-attribute-groups'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-attribute-group-attribute-groups--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-attribute-group-attribute-groups (progn (or (soap-xs-attribute-group-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-attribute-group cl-x))) (aref cl-x 5))) nil] 9 (#$ . 78097)])
(put 'soap-xs-attribute-group-attribute-groups 'compiler-macro 'soap-xs-attribute-group-attribute-groups--cmacro)
#@85 Access slot "attribute-groups" of `soap-xs-attribute-group' struct
CL-X.

(fn CL-X)
(defalias 'soap-xs-attribute-group-attribute-groups #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-attribute-group-tags type-of signal wrong-type-argument soap-xs-attribute-group 5] 5 (#$ . 78643)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-attribute-group-attribute-groups side-effect-free t] 4)
#@90 compiler-macro for inlining `soap-xs-attribute-group-reference'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-attribute-group-reference--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-attribute-group-reference (progn (or (soap-xs-attribute-group-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-attribute-group cl-x))) (aref cl-x 6))) nil] 9 (#$ . 79077)])
(put 'soap-xs-attribute-group-reference 'compiler-macro 'soap-xs-attribute-group-reference--cmacro)
#@78 Access slot "reference" of `soap-xs-attribute-group' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-attribute-group-reference #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-attribute-group-tags type-of signal wrong-type-argument soap-xs-attribute-group 6] 5 (#$ . 79588)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put soap-xs-attribute-group-reference side-effect-free t defalias copy-soap-xs-attribute-group copy-sequence] 4)
#@151 compiler-macro for inlining `make-soap-xs-attribute-group'.

(fn CL-WHOLE &cl-quote &key NAME NAMESPACE-TAG ID ATTRIBUTES ATTRIBUTE-GROUPS REFERENCE)
(defalias 'make-soap-xs-attribute-group--cmacro #[385 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\300\306\"A@\211\203R\211@\307>\203:\211AA\262
\202'\310>A@\203I\311\262
\202'\312\313@\"\210\202'\210\314\315\316\311\311&\207" [plist-member :name :namespace-tag :id :attributes :attribute-groups :reference (:name :namespace-tag :id :attributes :attribute-groups :reference :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag :id :attributes :attribute-groups :reference)" cl--defsubst-expand (name namespace-tag id attributes attribute-groups reference) (cl-block make-soap-xs-attribute-group (record 'soap-xs-attribute-group name namespace-tag id attributes attribute-groups reference))] 20 (#$ . 80064)])
(put 'make-soap-xs-attribute-group 'compiler-macro 'make-soap-xs-attribute-group--cmacro)
#@131 Constructor for objects of type `soap-xs-attribute-group'.

(fn &key NAME NAMESPACE-TAG ID ATTRIBUTES ATTRIBUTE-GROUPS REFERENCE)
(defalias 'make-soap-xs-attribute-group #[128 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\300\306\"A@\211\203R\211@\307>\203:\211AA\262
\202'\310>A@\203I\311\262
\202'\312\313@\"\210\202'\210\314\315&\207" [plist-member :name :namespace-tag :id :attributes :attribute-groups :reference (:name :namespace-tag :id :attributes :attribute-groups :reference :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag :id :attributes :attribute-groups :reference)" record soap-xs-attribute-group] 15 (#$ . 81118)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put make-soap-xs-attribute-group side-effect-free t cl-struct-define soap-xs-attribute-group nil soap-xs-type record ((cl-tag-slot) (name nil) (namespace-tag nil) (id nil) (attributes nil) (attribute-groups nil) (reference)) cl-struct-soap-xs-attribute-group-tags] 11)
#@55 Construct a `soap-xs-attribute' from NODE.

(fn NODE)
(defalias 'soap-xs-parse-attribute #[257 "\300
\211@\262
!\301=\204 \302\303\300\211@\262
!\300\211@\262
!C\304$\210\305
\306\"\307\305\310\"!\305\311\"\305\312\"\211\2059\307
!\204J\211\204J\313\314\315\"!\262\316\317\304&\207" [soap-l2wk xsd:attribute cl--assertion-failed (eq (soap-l2wk (xml-node-name node)) 'xsd:attribute) nil xml-get-attribute-or-nil name soap-l2fq type fixed ref soap-xs-parse-simple-type soap-xml-node-find-matching-child (xsd:restriction xsd:list xsd:union) record soap-xs-attribute] 13 (#$ . 82210)])
#@61 Construct a `soap-xs-attribute-group' from NODE.

(fn NODE)
(defalias 'soap-xs-parse-attribute-group #[257 "\302
\211@\262
!\211\303=\204\304\305\211C\306$\210\307\310\"\307\311\"\307\312\"\306\2038
\2038\313C\314\315\316\317#\320#\266\321\322\323\324\205H\325!&\262

\204\272\211AA\262
\211\203\271\211@\211;\204\262\302
\211@\262
!\211\326\267\210\202\262\327!\330!>\204\202\331\332\333D\"\210\334\334HBI\266\202\262\335!\330!	>\204\243\331\332\336D\"\210\337\337HBI\266\202\262\210
A\266\202\202V\210\207" [cl-struct-soap-xs-type-tags cl-struct-soap-xs-attribute-group-tags soap-l2wk xsd:attributeGroup cl--assertion-failed (eq node-name 'xsd:attributeGroup) nil xml-get-attribute-or-nil name id ref "name and ref set for attribute group %s" display-warning soap-client apply format :warning make-soap-xs-attribute-group :id :name :reference soap-l2fq #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (xsd:attribute 111 xsd:attributeGroup 144)) soap-xs-parse-attribute type-of signal wrong-type-argument soap-xs-type 4 soap-xs-parse-attribute-group soap-xs-attribute-group 5] 15 (#$ . 82820)])
#@219 Replace names in ATTRIBUTE with the referenced objects in the WSDL.
This is a specialization of `soap-resolve-references' for
`soap-xs-attribute' objects.

See also `soap-wsdl-resolve-references'.

(fn ATTRIBUTE WSDL)
(defalias 'soap-resolve-references-for-xs-attribute #[514 "\302!>\204\303\304\305D\"\210
\306H\302!>\204!\303\304\305D\"\210\307H\310\311!\205/
@\312\232\211\203<\313\262\314\262\202o\311!\203a\302!>\204S\303\304\305D\"\210\306\315\316#I\210\202o\302!	>\203o\317\"\210\311!\205\220\302!>\204\206\303\304\305D\"\210\307\315#I\207" [cl-struct-soap-xs-attribute-tags cl-struct-soap-xs-type-tags type-of signal wrong-type-argument soap-xs-attribute 3 5 soap-xs-element-p soap-name-p "http://www.w3.org/XML/1998/namespace" ("http://www.w3.org/2001/XMLSchema" . "string") soap-xs-basic-type-p soap-wsdl-get #[257 "\301
!>\203\n\302\207\303
!\207" [cl-struct-soap-xs-basic-type-tags type-of t soap-xs-simple-type-p] 3 "\n\n(fn TYPE)"] soap-resolve-references] 12 (#$ . 84011)])
(byte-code "\300\301\302\303\304\211\211\211\211&!\305\306#\207" [put soap-type-of record soap-xs-attribute nil soap-resolve-references soap-resolve-references-for-xs-attribute] 9)
#@231 Set slots in ATTRIBUTE-GROUP to the referenced objects in the WSDL.
This is a specialization of `soap-resolve-references' for
`soap-xs-attribute-group' objects.

See also `soap-wsdl-resolve-references'.

(fn ATTRIBUTE-GROUP WSDL)
(defalias 'soap-resolve-references-for-xs-attribute-group #[514 "\301!>\204\302\303\304D\"\210
\305H\306
!\205\361\307
\310#\301
!>\204,\302\303\304D\"\210\211\311H\211\203B\211@\312
\"\210
A\266\202\202/\210\301!>\204S\302\303\304D\"\210\313\301!>\204d\302\303\304D\"\210\313HI\210\301!>\204y\302\303\304D\"\210\314\301!>\204\212\302\303\304D\"\210\314HI\210\301!>\204\237\302\303\304D\"\210\305\315I\210\301!>\204\264\302\303\304D\"\210\311\301!>\204\305\302\303\304D\"\210\311HI\210\301!>\204\332\302\303\304D\"\210\316\301!>\204\353\302\303\304D\"\210\316HI\262
\207" [cl-struct-soap-xs-attribute-group-tags type-of signal wrong-type-argument soap-xs-attribute-group 6 soap-name-p soap-wsdl-get soap-xs-attribute-group-p 4 soap-resolve-references 1 3 nil 5] 10 (#$ . 85240)])
(byte-code "\300\301\302\303\304\211\211\211\211\211&!\305\306#\207" [put soap-type-of record soap-xs-attribute-group nil soap-resolve-references soap-resolve-references-for-xs-attribute-group] 10)
#@78 compiler-macro for inlining `soap-xs-simple-type-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-simple-type-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-simple-type-p (and (memq (type-of cl-x) cl-struct-soap-xs-simple-type-tags) t)) nil] 9 (#$ . 86519)])
(put 'soap-xs-simple-type-p 'compiler-macro 'soap-xs-simple-type-p--cmacro)
#@13 

(fn CL-X)
(defalias 'soap-xs-simple-type-p #[257 "\301
!>\205	\302\207" [cl-struct-soap-xs-simple-type-tags type-of t] 3 (#$ . 86908)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put soap-xs-simple-type-p side-effect-free error-free put soap-xs-simple-type cl-deftype-satisfies] 5)
#@81 compiler-macro for inlining `soap-xs-simple-type-name'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-simple-type-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-simple-type-name (progn (or (soap-xs-simple-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-simple-type cl-x))) (aref cl-x 1))) nil] 9 (#$ . 87219)])
(put 'soap-xs-simple-type-name 'compiler-macro 'soap-xs-simple-type-name--cmacro)
#@69 Access slot "name" of `soap-xs-simple-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-simple-type-name #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-simple-type-tags type-of signal wrong-type-argument soap-xs-simple-type 1] 5 (#$ . 87677)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-simple-type-name side-effect-free t] 4)
#@90 compiler-macro for inlining `soap-xs-simple-type-namespace-tag'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-simple-type-namespace-tag--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-simple-type-namespace-tag (progn (or (soap-xs-simple-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-simple-type cl-x))) (aref cl-x 2))) nil] 9 (#$ . 88055)])
(put 'soap-xs-simple-type-namespace-tag 'compiler-macro 'soap-xs-simple-type-namespace-tag--cmacro)
#@78 Access slot "namespace-tag" of `soap-xs-simple-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-simple-type-namespace-tag #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-simple-type-tags type-of signal wrong-type-argument soap-xs-simple-type 2] 5 (#$ . 88558)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-simple-type-namespace-tag side-effect-free t] 4)
#@79 compiler-macro for inlining `soap-xs-simple-type-id'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-simple-type-id--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-simple-type-id (progn (or (soap-xs-simple-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-simple-type cl-x))) (aref cl-x 3))) nil] 9 (#$ . 88963)])
(put 'soap-xs-simple-type-id 'compiler-macro 'soap-xs-simple-type-id--cmacro)
#@67 Access slot "id" of `soap-xs-simple-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-simple-type-id #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-simple-type-tags type-of signal wrong-type-argument soap-xs-simple-type 3] 5 (#$ . 89411)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-simple-type-id side-effect-free t] 4)
#@87 compiler-macro for inlining `soap-xs-simple-type-attributes'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-simple-type-attributes--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-simple-type-attributes (progn (or (soap-xs-simple-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-simple-type cl-x))) (aref cl-x 4))) nil] 9 (#$ . 89783)])
(put 'soap-xs-simple-type-attributes 'compiler-macro 'soap-xs-simple-type-attributes--cmacro)
#@75 Access slot "attributes" of `soap-xs-simple-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-simple-type-attributes #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-simple-type-tags type-of signal wrong-type-argument soap-xs-simple-type 4] 5 (#$ . 90271)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-simple-type-attributes side-effect-free t] 4)
#@93 compiler-macro for inlining `soap-xs-simple-type-attribute-groups'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-simple-type-attribute-groups--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-simple-type-attribute-groups (progn (or (soap-xs-simple-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-simple-type cl-x))) (aref cl-x 5))) nil] 9 (#$ . 90667)])
(put 'soap-xs-simple-type-attribute-groups 'compiler-macro 'soap-xs-simple-type-attribute-groups--cmacro)
#@81 Access slot "attribute-groups" of `soap-xs-simple-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-simple-type-attribute-groups #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-simple-type-tags type-of signal wrong-type-argument soap-xs-simple-type 5] 5 (#$ . 91185)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-simple-type-attribute-groups side-effect-free t] 4)
#@81 compiler-macro for inlining `soap-xs-simple-type-base'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-simple-type-base--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-simple-type-base (progn (or (soap-xs-simple-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-simple-type cl-x))) (aref cl-x 6))) nil] 9 (#$ . 91599)])
(put 'soap-xs-simple-type-base 'compiler-macro 'soap-xs-simple-type-base--cmacro)
#@69 Access slot "base" of `soap-xs-simple-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-simple-type-base #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-simple-type-tags type-of signal wrong-type-argument soap-xs-simple-type 6] 5 (#$ . 92057)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-simple-type-base side-effect-free t] 4)
#@88 compiler-macro for inlining `soap-xs-simple-type-enumeration'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-simple-type-enumeration--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-simple-type-enumeration (progn (or (soap-xs-simple-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-simple-type cl-x))) (aref cl-x 7))) nil] 9 (#$ . 92435)])
(put 'soap-xs-simple-type-enumeration 'compiler-macro 'soap-xs-simple-type-enumeration--cmacro)
#@76 Access slot "enumeration" of `soap-xs-simple-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-simple-type-enumeration #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-simple-type-tags type-of signal wrong-type-argument soap-xs-simple-type 7] 5 (#$ . 92928)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-simple-type-enumeration side-effect-free t] 4)
#@84 compiler-macro for inlining `soap-xs-simple-type-pattern'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-simple-type-pattern--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-simple-type-pattern (progn (or (soap-xs-simple-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-simple-type cl-x))) (aref cl-x 8))) nil] 9 (#$ . 93327)])
(put 'soap-xs-simple-type-pattern 'compiler-macro 'soap-xs-simple-type-pattern--cmacro)
#@72 Access slot "pattern" of `soap-xs-simple-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-simple-type-pattern #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-simple-type-tags type-of signal wrong-type-argument soap-xs-simple-type 8] 5 (#$ . 93800)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-simple-type-pattern side-effect-free t] 4)
#@89 compiler-macro for inlining `soap-xs-simple-type-length-range'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-simple-type-length-range--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-simple-type-length-range (progn (or (soap-xs-simple-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-simple-type cl-x))) (aref cl-x 9))) nil] 9 (#$ . 94187)])
(put 'soap-xs-simple-type-length-range 'compiler-macro 'soap-xs-simple-type-length-range--cmacro)
#@77 Access slot "length-range" of `soap-xs-simple-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-simple-type-length-range #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-simple-type-tags type-of signal wrong-type-argument soap-xs-simple-type 9] 5 (#$ . 94685)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-simple-type-length-range side-effect-free t] 4)
#@90 compiler-macro for inlining `soap-xs-simple-type-integer-range'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-simple-type-integer-range--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-simple-type-integer-range (progn (or (soap-xs-simple-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-simple-type cl-x))) (aref cl-x 10))) nil] 9 (#$ . 95087)])
(put 'soap-xs-simple-type-integer-range 'compiler-macro 'soap-xs-simple-type-integer-range--cmacro)
#@78 Access slot "integer-range" of `soap-xs-simple-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-simple-type-integer-range #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-simple-type-tags type-of signal wrong-type-argument soap-xs-simple-type 10] 5 (#$ . 95591)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-simple-type-integer-range side-effect-free t] 4)
#@84 compiler-macro for inlining `soap-xs-simple-type-is-list'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-simple-type-is-list--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-simple-type-is-list (progn (or (soap-xs-simple-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-simple-type cl-x))) (aref cl-x 11))) nil] 9 (#$ . 95997)])
(put 'soap-xs-simple-type-is-list 'compiler-macro 'soap-xs-simple-type-is-list--cmacro)
#@72 Access slot "is-list" of `soap-xs-simple-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-simple-type-is-list #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-simple-type-tags type-of signal wrong-type-argument soap-xs-simple-type 11] 5 (#$ . 96471)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put soap-xs-simple-type-is-list side-effect-free t defalias copy-soap-xs-simple-type copy-sequence] 4)
#@197 compiler-macro for inlining `make-soap-xs-simple-type'.

(fn CL-WHOLE &cl-quote &key NAME NAMESPACE-TAG ID ATTRIBUTES ATTRIBUTE-GROUPS BASE ENUMERATION PATTERN LENGTH-RANGE INTEGER-RANGE IS-LIST)
(defalias 'make-soap-xs-simple-type--cmacro #[385 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\300\306\"A@\300\307\"A@\300\310\"A@\300	\311\"A@\300\n\312\"A@\300\313\"A@\211\203u\211@\314>\203]\211AA\262
\202J\315
>A@\203l\316\262
\202J\317\320@\"\210\202J\210\321\322\323\316\316&\207" [plist-member :name :namespace-tag :id :attributes :attribute-groups :base :enumeration :pattern :length-range :integer-range :is-list (:name :namespace-tag :id :attributes :attribute-groups :base :enumeration :pattern :length-range :integer-range :is-list :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag :id :attributes :attribute-groups :base :enumeration :pattern :length-range :integer-range :is-list)" cl--defsubst-expand (name namespace-tag id attributes attribute-groups base enumeration pattern length-range integer-range is-list) (cl-block make-soap-xs-simple-type (record 'soap-xs-simple-type name namespace-tag id attributes attribute-groups base enumeration pattern length-range integer-range is-list))] 30 (#$ . 96918)])
(put 'make-soap-xs-simple-type 'compiler-macro 'make-soap-xs-simple-type--cmacro)
#@177 Constructor for objects of type `soap-xs-simple-type'.

(fn &key NAME NAMESPACE-TAG ID ATTRIBUTES ATTRIBUTE-GROUPS BASE ENUMERATION PATTERN LENGTH-RANGE INTEGER-RANGE IS-LIST)
(defalias 'make-soap-xs-simple-type #[128 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\300\306\"A@\300\307\"A@\300\310\"A@\300	\311\"A@\300\n\312\"A@\300\313\"A@\211\203u\211@\314>\203]\211AA\262
\202J\315
>A@\203l\316\262
\202J\317\320@\"\210\202J\210\321\322\f\f\f\f\f\f\f\f\f\f\f&\f\207" [plist-member :name :namespace-tag :id :attributes :attribute-groups :base :enumeration :pattern :length-range :integer-range :is-list (:name :namespace-tag :id :attributes :attribute-groups :base :enumeration :pattern :length-range :integer-range :is-list :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag :id :attributes :attribute-groups :base :enumeration :pattern :length-range :integer-range :is-list)" record soap-xs-simple-type] 25 (#$ . 98344)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put make-soap-xs-simple-type side-effect-free t cl-struct-define soap-xs-simple-type nil soap-xs-type record ((cl-tag-slot) (name nil) (namespace-tag nil) (id nil) (attributes nil) (attribute-groups nil) (base) (enumeration) (pattern) (length-range) (integer-range) (is-list)) cl-struct-soap-xs-simple-type-tags] 11)
#@73 Construct an `soap-xs-simple-type' object from the XML NODE.

(fn NODE)
(defalias 'soap-xs-parse-simple-type #[257 "\301
\211@\262
!\302>\204\303\304\305\306\301\211@\262
!C$\210\307
\310\"\307\311\"\312\313\306\211\211\211\211\211\211\211&\f\314\315\"\301
\211@\262
!\211\316\267\202f\317\"\266\202m\320\"\266\202m\321\"\266\202m\322\"\266\202m\323\324\325#\266
\207" [soap-target-xmlns soap-l2wk #1=(xsd:simpleType xsd:simpleContent) cl--assertion-failed (memq (soap-l2wk (xml-node-name node)) '#1#) "expecting xsd:simpleType or xsd:simpleContent node, got %s" nil xml-get-attribute-or-nil name id record soap-xs-simple-type soap-xml-node-find-matching-child (xsd:restriction xsd:extension xsd:union xsd:list) #s(hash-table size 4 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (xsd:restriction 66 xsd:extension 75 xsd:union 84 xsd:list 93)) soap-xs-add-restriction soap-xs-add-extension soap-xs-add-union soap-xs-add-list error "cl-ecase failed: %s, %s" (xsd:restriction xsd:extension xsd:union xsd:list)] 16 (#$ . 99780)])
#@89 Add restrictions defined in XML NODE to TYPE, an `soap-xs-simple-type'.

(fn NODE TYPE)
(defalias 'soap-xs-add-restriction #[514 "\301\211@\262
!\302=\204\303\304\305\306\301\211@\262
!C$\210\307
!>\204*\310\311\312D\"\210\211\313\314\315\316\"\2067\317\266\202!I\210
\211AA\262
\211\205\271\211@\211;\204\262\211\320\316\"\206W\317\266\202\301\211@\262
!\211\321\267\266\202\262\307!>\204x\310\311\312D\"\210\322\322HBI\266\202\262\307!>\204\226\310\311\312D\"\210\323\324\325!\326QI\266\202\262\327!\307!>\204\270\310\311\312D\"\210\330\211BI\266\202\262\327!\307!>\204\327\310\311\312D\"\210\330\307!>\204\352\310\311\312\nD\"\210\330H\203\f
\307	!>\204
\310\311\312D\"\210\330HAB\202
CI\266\202\262\327!\307!>\204(
\310\311\312D\"\210\330\307!>\204;
\310\311\312\nD\"\210\330H\203]
\307!>\204S
\310\311\312\nD\"\210\330H@B\202`
\306BI\266\202\262\327!\307!>\204z
\310\311\312D\"\210\331\307!>\204\215
\310\311\312\nD\"\210\331H\203\260
T\307	!>\204\247
\310\311\312D\"\210\331HAB\202\263
TCI\266\202\262\327!\307!>\204\315
\310\311\312D\"\210\331\307!>\204\340
\310\311\312\nD\"\210\331H\203\307!>\204\370
\310\311\312\nD\"\210\331H@SB\202\306SBI\266\202\262\327!\307!>\204!\310\311\312D\"\210\331\307!>\2044\310\311\312\nD\"\210\331H\203V\307	!>\204M\310\311\312D\"\210\331HAB\202XCI\266\202\262\327!\307!>\204r\310\311\312D\"\210\331\307!>\204\205\310\311\312\nD\"\210\331H\203\247\307!>\204\235\310\311\312\nD\"\210\331H@B\202\252\306BI\266\202\262\266
A\266\202\202B\207" [cl-struct-soap-xs-simple-type-tags soap-l2wk xsd:restriction cl--assertion-failed (eq (soap-l2wk (xml-node-name node)) 'xsd:restriction) "expecting xsd:restriction node, got %s" nil type-of signal wrong-type-argument soap-xs-simple-type 6 soap-l2fq base xml-get-attribute-or-nil "" value #s(hash-table size 9 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (xsd:enumeration 104 xsd:pattern 134 xsd:length 164 xsd:minLength 195 xsd:maxLength 276 xsd:minExclusive 358 xsd:maxExclusive 441 xsd:minInclusive 525 xsd:maxInclusive 606)) 7 8 "\\`" xsdre-translate "\\'" string-to-number 9 10] 14 (#$ . 100857)])
#@90 Add union members defined in XML NODE to TYPE, an `soap-xs-simple-type'.

(fn NODE TYPE)
(defalias 'soap-xs-add-union #[514 "\301\211@\262
!\302=\204\303\304\305\306\301\211@\262
!C$\210\307
!>\204*\310\311\312D\"\210\211\313\314\315\316\317\320\"\2068\321!\"I\210\306\322\323\"\211\203U\211@\324
!B\262
A\266\202\202A\210\307!>\204e\310\311\312D\"\210
\313\325\307!>\204x\310\311\312D\"\210\313H\237\"I\207" [cl-struct-soap-xs-simple-type-tags soap-l2wk xsd:union cl--assertion-failed (eq (soap-l2wk (xml-node-name node)) 'xsd:union) "expecting xsd:union node, got %s" nil type-of signal wrong-type-argument soap-xs-simple-type 6 mapcar soap-l2fq split-string xml-get-attribute-or-nil memberTypes "" soap-xml-get-children1 xsd:simpleType soap-xs-parse-simple-type append] 10 (#$ . 103174)])
#@80 Add list defined in XML NODE to TYPE, a `soap-xs-simple-type'.

(fn NODE TYPE)
(defalias 'soap-xs-add-list #[514 "\302\211@\262
!\303=\204\304\305\306\307\302\211@\262
!C$\210\310\311\"\312\313\"
\203j\211G\314U\203G\315!>\204=\316\317\320D\"\210\321\322!I\210\202\257\323\315!	>\204X\316\317\324D\"\210\325HC\326\327\330\331#\332#\266\202\257\211G\325U\203\217\315!>\204\200\316\317\320D\"\210\321\333\312\313\"@!I\210\202\257\334\315!	>\204\240\316\317\324D\"\210\325HC\326\327\330\331#\332#\266\315!>\204\276\316\317\320D\"\210\335\336I\207" [cl-struct-soap-xs-simple-type-tags cl-struct-soap-xs-type-tags soap-l2wk xsd:list cl--assertion-failed (eq (soap-l2wk (xml-node-name node)) 'xsd:list) "expecting xsd:list node, got %s" nil xml-get-attribute-or-nil itemType soap-xml-get-children1 xsd:simpleType 0 type-of signal wrong-type-argument soap-xs-simple-type 6 soap-l2fq "xsd:list node with itemType has more than zero children: %s" soap-xs-type 1 display-warning soap-client apply format :warning soap-xs-parse-simple-type "xsd:list node has more than one child %s" 11 t] 12 (#$ . 103999)])
#@94 Add the extended type defined in XML NODE to TYPE, an `soap-xs-simple-type'.

(fn NODE TYPE)
(defalias 'soap-xs-add-extension #[514 "\302
!>\204\303\304\305D\"\210\211\306\307\310\311\"\206\312\266\202!I\210\313\314\"\211\203P\211@\315
!\302!	>\204>\303\304\316D\"\210\317\317HBI\266
A\266\202\202%\210\313\320\"\211\205\200\211@\321
!\302!	>\204n\303\304\316D\"\210\322\322HBI\266
A\266\202\202U\207" [cl-struct-soap-xs-simple-type-tags cl-struct-soap-xs-type-tags type-of signal wrong-type-argument soap-xs-simple-type 6 soap-l2fq base xml-get-attribute-or-nil "" soap-xml-get-children1 xsd:attribute soap-xs-parse-attribute soap-xs-type 4 xsd:attributeGroup soap-xs-parse-attribute-group 5] 10 (#$ . 105149)])
#@62 Validate VALUE against the basic type TYPE.

(fn VALUE TYPE)
(defalias 'soap-validate-xs-basic-type #[514 "\301
!>\204\302\303\304D\"\210\211\305H\306
\307\"\203\207\211\310N\211\203<\211\311@AB\"\266\202\2033\207\312\313\314!#\207\312\315\"\207" [cl-struct-soap-xs-basic-type-tags type-of signal wrong-type-argument soap-xs-basic-type 6 memql (anyType Array byte []) rng-xsd-convert apply error "Invalid %s: %s" symbol-name "Don't know how to convert %s"] 10 (#$ . 105901)])
#@67 Validate VALUE against the restrictions of TYPE.

(fn VALUE TYPE)
(defalias 'soap-validate-xs-simple-type #[514 "\304
!>\204\305\306\307D\"\210\211\310H\311C
<\203v\3122q
\211\203a\211@\3131P\304
!>\203;\314\312\315\"\"\202K\304
!	>\205K\314\312\316\"\"0\210\202Z
A@\242B\240\266
A\266\202\202\210\211\242\205p\317\320\321\242\237\322#!0\266\202\243
\323\3242g
\304!>\204\213\305\306\307D\"\210\325H\211G\326V\203\241
\235\204\241
\327#\210\210\304!>\204\262\305\306\307D\"\210\330H\211\203\320\211\311\331\332#)\266\203\204\320
\333#\210\210\304!>\204\341\305\306\307D\"\210\334H\211\203
;\204\363
\335#\210\211@\203
G
@Y\204

\336@#\210\211A\203
G
AX\204

\337A#\210\210\304!>\204,
\305\306\307D\"\210\340H\211\205d
\247\204>

\341#\210\211@\203Q

@Y\204Q

\342@#\210\211A\205d

AX?\205d

\343A#\262
0\266\211\242\203\241
\317\344\304!>\204\202
\305\306\345D\"\210\326H\206\234
\304!>\204\231
\305\306\345D\"\210\346H\242@$\210\266
\207" [cl-struct-soap-xs-simple-type-tags cl-struct-soap-xs-basic-type-tags inhibit-changing-match-data cl-struct-soap-xs-type-tags type-of signal wrong-type-argument soap-xs-simple-type 6 nil valid (error) throw soap-validate-xs-simple-type soap-validate-xs-basic-type error mapconcat identity "; and: " #[771 "\300\"\242B\240\210\301\302\303\"\207" [format throw invalid nil] 7 "\n\n(fn MESSAGES FORMAT VALUE)"] invalid 7 1 "bad value, should be one of %s" 8 t string-match "bad value, should match pattern %s" 9 "bad value, should be a string with length range %s" "short string, should be at least %s chars" "long string, should be at most %s chars" 10 "bad value, should be a number with range %s" "small value, should be at least %s" "big value, should be at most %s" "Xs-simple-type(%s, %s): %s" soap-xs-type 3] 13 (#$ . 106401)])
#@211 Replace names in TYPE with the referenced objects in the WSDL.
This is a specialization of `soap-resolve-references' for
`soap-xs-simple-type' objects.

See also `soap-wsdl-resolve-references'.

(fn TYPE WSDL)
(defalias 'soap-resolve-references-for-xs-simple-type #[514 "\303!>\204\304\305\306D\"\210
\307H\211\2037\310
\311!\"@\211\2036\303!>\2041\304\305\306D\"\210\307I\210\210\210\303!	>\204G\304\305\312D\"\210
\313H\314
!\203l\303!	>\204_\304\305\312D\"\210\313\315\316#I\266\202\246\303
!\n>\203}\317
\"\266\202\246\211<\203\241\303!	>\204\221\304\305\312D\"\210\313\320\321\322\"\"I\266\202\246\323\324!\266\303!\n>\204\265\304\305\325D\"\210
\326H\211\203\312\211@\317
\"\210
A\266\202\202\270\210\303!\n>\204\332\304\305\325D\"\210
\327H\211\205\357\211@\317
\"\210
A\266\202\202\335\207" [cl-struct-soap-element-tags cl-struct-soap-xs-simple-type-tags cl-struct-soap-xs-type-tags type-of signal wrong-type-argument soap-element 2 rassoc soap-wsdl-alias-table soap-xs-simple-type 6 soap-name-p soap-wsdl-get soap-xs-type-p soap-resolve-references mapcar make-closure #[257 "\302
!\203\f\303
\300\304#\207\305
!	>\203\306
\300\"\210\207\207" [V0 cl-struct-soap-xs-type-tags soap-name-p soap-wsdl-get soap-xs-type-p type-of soap-resolve-references] 5 "\n\n(fn TYPE)"] error "Oops" soap-xs-type 4 5] 9 (#$ . 108289)])
#@333 Encode the XML attributes for VALUE according to TYPE.
The attributes are inserted in the current buffer at the current
position.  If TYPE has no attributes, the xsi:type attribute and
an optional xsi:nil attribute are added.

This is a specialization of `soap-encode-attributes' for
`soap-xs-simple-type' objects.

(fn VALUE TYPE)
(defalias 'soap-encode-xs-simple-type-attributes #[514 "\302
!\211\211\203x\211@\303
!>\204\304\305\306D\"\210\211\307H\303!	>\204+\304\305\310D\"\210
\311H\203O\312
\313\303!	>\204D\304\305\310D\"\210\311H\314\261\266\202q\211\203o\211@\315\242!\232\203h\312\313A\314\261\210
A\266\202\202P\266
A\266\202\202\210\211?\205\215\316\317!\314\261\210?\205\215\320c\207" [cl-struct-soap-element-tags cl-struct-soap-xs-attribute-tags soap-get-xs-attributes type-of signal wrong-type-argument soap-element 1 soap-xs-attribute 4 " " "=\"" "\"" symbol-name " xsi:type=\"" soap-element-fq-name " xsi:nil=\"true\""] 13 (#$ . 109678)])
#@206 Encode the VALUE according to TYPE.
The data is inserted in the current buffer at the current
position.

This is a specialization of `soap-encode-value' for
`soap-xs-simple-type' objects.

(fn VALUE TYPE)
(defalias 'soap-encode-xs-simple-type #[514 "\301\"\210\302
!>\204\303\304\305D\"\210\211\306H\203^\307!\211\203D\211@\310
\302!>\2045\303\304\305D\"\210\311H\"\210\312c\210
A\266\202\202\210\310\313!@\302!>\204Y\303\304\305D\"\210\311H\"\207\310\302!>\204o\303\304\305D\"\210\311H\"\207" [cl-struct-soap-xs-simple-type-tags soap-validate-xs-simple-type type-of signal wrong-type-argument soap-xs-simple-type 11 butlast soap-encode-value 6 " " last] 10 (#$ . 110676)])
#@256 Use TYPE, a `soap-xs-simple-type', to decode the contents of NODE.
A LISP value is returned based on the contents of NODE and the
type-info stored in TYPE.

This is a specialization of `soap-decode-type' for
`soap-xs-simple-type' objects.

(fn TYPE NODE)
(defalias 'soap-decode-xs-simple-type #[514 "\301!>\204\302\303\304D\"\210
\305H\203\306
\211AA\262
@!\207\307\301!>\204/\302\303\304D\"\210\310H\"\311
\"\207" [cl-struct-soap-xs-simple-type-tags type-of signal wrong-type-argument soap-xs-simple-type 11 split-string soap-decode-type 6 soap-validate-xs-simple-type] 7 (#$ . 111386)])
(byte-code "\300\301\302\303\211\211\211\211\211\211\211\211\211\211&\f!\304
\305\306#\210\304
\307\310#\210\304
\311\312#\210\304
\313\314#\210\207" [soap-type-of record soap-xs-simple-type nil put soap-resolve-references soap-resolve-references-for-xs-simple-type soap-attribute-encoder soap-encode-xs-simple-type-attributes soap-encoder soap-encode-xs-simple-type soap-decoder soap-decode-xs-simple-type] 14)
#@79 compiler-macro for inlining `soap-xs-complex-type-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-complex-type-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-complex-type-p (and (memq (type-of cl-x) cl-struct-soap-xs-complex-type-tags) t)) nil] 9 (#$ . 112407)])
(put 'soap-xs-complex-type-p 'compiler-macro 'soap-xs-complex-type-p--cmacro)
#@13 

(fn CL-X)
(defalias 'soap-xs-complex-type-p #[257 "\301
!>\205	\302\207" [cl-struct-soap-xs-complex-type-tags type-of t] 3 (#$ . 112803)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put soap-xs-complex-type-p side-effect-free error-free put soap-xs-complex-type cl-deftype-satisfies] 5)
#@82 compiler-macro for inlining `soap-xs-complex-type-name'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-complex-type-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-complex-type-name (progn (or (soap-xs-complex-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-complex-type cl-x))) (aref cl-x 1))) nil] 9 (#$ . 113119)])
(put 'soap-xs-complex-type-name 'compiler-macro 'soap-xs-complex-type-name--cmacro)
#@70 Access slot "name" of `soap-xs-complex-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-complex-type-name #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-complex-type-tags type-of signal wrong-type-argument soap-xs-complex-type 1] 5 (#$ . 113585)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-complex-type-name side-effect-free t] 4)
#@91 compiler-macro for inlining `soap-xs-complex-type-namespace-tag'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-complex-type-namespace-tag--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-complex-type-namespace-tag (progn (or (soap-xs-complex-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-complex-type cl-x))) (aref cl-x 2))) nil] 9 (#$ . 113969)])
(put 'soap-xs-complex-type-namespace-tag 'compiler-macro 'soap-xs-complex-type-namespace-tag--cmacro)
#@79 Access slot "namespace-tag" of `soap-xs-complex-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-complex-type-namespace-tag #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-complex-type-tags type-of signal wrong-type-argument soap-xs-complex-type 2] 5 (#$ . 114480)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-complex-type-namespace-tag side-effect-free t] 4)
#@80 compiler-macro for inlining `soap-xs-complex-type-id'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-complex-type-id--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-complex-type-id (progn (or (soap-xs-complex-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-complex-type cl-x))) (aref cl-x 3))) nil] 9 (#$ . 114891)])
(put 'soap-xs-complex-type-id 'compiler-macro 'soap-xs-complex-type-id--cmacro)
#@68 Access slot "id" of `soap-xs-complex-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-complex-type-id #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-complex-type-tags type-of signal wrong-type-argument soap-xs-complex-type 3] 5 (#$ . 115347)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-complex-type-id side-effect-free t] 4)
#@88 compiler-macro for inlining `soap-xs-complex-type-attributes'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-complex-type-attributes--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-complex-type-attributes (progn (or (soap-xs-complex-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-complex-type cl-x))) (aref cl-x 4))) nil] 9 (#$ . 115725)])
(put 'soap-xs-complex-type-attributes 'compiler-macro 'soap-xs-complex-type-attributes--cmacro)
#@76 Access slot "attributes" of `soap-xs-complex-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-complex-type-attributes #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-complex-type-tags type-of signal wrong-type-argument soap-xs-complex-type 4] 5 (#$ . 116221)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-complex-type-attributes side-effect-free t] 4)
#@94 compiler-macro for inlining `soap-xs-complex-type-attribute-groups'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-complex-type-attribute-groups--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-complex-type-attribute-groups (progn (or (soap-xs-complex-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-complex-type cl-x))) (aref cl-x 5))) nil] 9 (#$ . 116623)])
(put 'soap-xs-complex-type-attribute-groups 'compiler-macro 'soap-xs-complex-type-attribute-groups--cmacro)
#@82 Access slot "attribute-groups" of `soap-xs-complex-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-complex-type-attribute-groups #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-complex-type-tags type-of signal wrong-type-argument soap-xs-complex-type 5] 5 (#$ . 117149)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-complex-type-attribute-groups side-effect-free t] 4)
#@87 compiler-macro for inlining `soap-xs-complex-type-indicator'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-complex-type-indicator--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-complex-type-indicator (progn (or (soap-xs-complex-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-complex-type cl-x))) (aref cl-x 6))) nil] 9 (#$ . 117569)])
(put 'soap-xs-complex-type-indicator 'compiler-macro 'soap-xs-complex-type-indicator--cmacro)
#@75 Access slot "indicator" of `soap-xs-complex-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-complex-type-indicator #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-complex-type-tags type-of signal wrong-type-argument soap-xs-complex-type 6] 5 (#$ . 118060)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-complex-type-indicator side-effect-free t] 4)
#@82 compiler-macro for inlining `soap-xs-complex-type-base'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-complex-type-base--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-complex-type-base (progn (or (soap-xs-complex-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-complex-type cl-x))) (aref cl-x 7))) nil] 9 (#$ . 118459)])
(put 'soap-xs-complex-type-base 'compiler-macro 'soap-xs-complex-type-base--cmacro)
#@70 Access slot "base" of `soap-xs-complex-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-complex-type-base #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-complex-type-tags type-of signal wrong-type-argument soap-xs-complex-type 7] 5 (#$ . 118925)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-complex-type-base side-effect-free t] 4)
#@86 compiler-macro for inlining `soap-xs-complex-type-elements'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-complex-type-elements--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-complex-type-elements (progn (or (soap-xs-complex-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-complex-type cl-x))) (aref cl-x 8))) nil] 9 (#$ . 119309)])
(put 'soap-xs-complex-type-elements 'compiler-macro 'soap-xs-complex-type-elements--cmacro)
#@74 Access slot "elements" of `soap-xs-complex-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-complex-type-elements #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-complex-type-tags type-of signal wrong-type-argument soap-xs-complex-type 8] 5 (#$ . 119795)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-complex-type-elements side-effect-free t] 4)
#@87 compiler-macro for inlining `soap-xs-complex-type-optional?'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-complex-type-optional\?--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-complex-type-optional\? (progn (or (soap-xs-complex-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-complex-type cl-x))) (aref cl-x 9))) nil] 9 (#$ . 120191)])
(put 'soap-xs-complex-type-optional\? 'compiler-macro 'soap-xs-complex-type-optional\?--cmacro)
#@75 Access slot "optional?" of `soap-xs-complex-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-complex-type-optional\? #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-complex-type-tags type-of signal wrong-type-argument soap-xs-complex-type 9] 5 (#$ . 120686)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-complex-type-optional\? side-effect-free t] 4)
#@87 compiler-macro for inlining `soap-xs-complex-type-multiple?'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-complex-type-multiple\?--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-complex-type-multiple\? (progn (or (soap-xs-complex-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-complex-type cl-x))) (aref cl-x 10))) nil] 9 (#$ . 121087)])
(put 'soap-xs-complex-type-multiple\? 'compiler-macro 'soap-xs-complex-type-multiple\?--cmacro)
#@75 Access slot "multiple?" of `soap-xs-complex-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-complex-type-multiple\? #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-complex-type-tags type-of signal wrong-type-argument soap-xs-complex-type 10] 5 (#$ . 121583)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-xs-complex-type-multiple\? side-effect-free t] 4)
#@86 compiler-macro for inlining `soap-xs-complex-type-is-group'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-xs-complex-type-is-group--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-xs-complex-type-is-group (progn (or (soap-xs-complex-type-p cl-x) (signal 'wrong-type-argument (list 'soap-xs-complex-type cl-x))) (aref cl-x 11))) nil] 9 (#$ . 121985)])
(put 'soap-xs-complex-type-is-group 'compiler-macro 'soap-xs-complex-type-is-group--cmacro)
#@74 Access slot "is-group" of `soap-xs-complex-type' struct CL-X.

(fn CL-X)
(defalias 'soap-xs-complex-type-is-group #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-complex-type-tags type-of signal wrong-type-argument soap-xs-complex-type 11] 5 (#$ . 122472)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put soap-xs-complex-type-is-group side-effect-free t defalias copy-soap-xs-complex-type copy-sequence] 4)
#@197 compiler-macro for inlining `make-soap-xs-complex-type'.

(fn CL-WHOLE &cl-quote &key NAME NAMESPACE-TAG ID ATTRIBUTES ATTRIBUTE-GROUPS INDICATOR BASE ELEMENTS OPTIONAL\=\? MULTIPLE\=\? IS-GROUP)
(defalias 'make-soap-xs-complex-type--cmacro #[385 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\300\306\"A@\300\307\"A@\300\310\"A@\300	\311\"A@\300\n\312\"A@\300\313\"A@\211\203u\211@\314>\203]\211AA\262
\202J\315
>A@\203l\316\262
\202J\317\320@\"\210\202J\210\321\322\323\316\316&\207" [plist-member :name :namespace-tag :id :attributes :attribute-groups :indicator :base :elements :optional\? :multiple\? :is-group (:name :namespace-tag :id :attributes :attribute-groups :indicator :base :elements :optional\? :multiple\? :is-group :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag :id :attributes :attribute-groups :indicator :base :elements :optional? :multiple? :is-group)" cl--defsubst-expand (name namespace-tag id attributes attribute-groups indicator base elements optional\? multiple\? is-group) (cl-block make-soap-xs-complex-type (record 'soap-xs-complex-type name namespace-tag id attributes attribute-groups indicator base elements optional\? multiple\? is-group))] 30 (#$ . 122929)])
(put 'make-soap-xs-complex-type 'compiler-macro 'make-soap-xs-complex-type--cmacro)
#@177 Constructor for objects of type `soap-xs-complex-type'.

(fn &key NAME NAMESPACE-TAG ID ATTRIBUTES ATTRIBUTE-GROUPS INDICATOR BASE ELEMENTS OPTIONAL\=\? MULTIPLE\=\? IS-GROUP)
(defalias 'make-soap-xs-complex-type #[128 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\300\306\"A@\300\307\"A@\300\310\"A@\300	\311\"A@\300\n\312\"A@\300\313\"A@\211\203u\211@\314>\203]\211AA\262
\202J\315
>A@\203l\316\262
\202J\317\320@\"\210\202J\210\321\322\f\f\f\f\f\f\f\f\f\f\f&\f\207" [plist-member :name :namespace-tag :id :attributes :attribute-groups :indicator :base :elements :optional\? :multiple\? :is-group (:name :namespace-tag :id :attributes :attribute-groups :indicator :base :elements :optional\? :multiple\? :is-group :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag :id :attributes :attribute-groups :indicator :base :elements :optional? :multiple? :is-group)" record soap-xs-complex-type] 25 (#$ . 124334)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put make-soap-xs-complex-type side-effect-free t cl-struct-define soap-xs-complex-type nil soap-xs-type record ((cl-tag-slot) (name nil) (namespace-tag nil) (id nil) (attributes nil) (attribute-groups nil) (indicator) (base) (elements) (optional\?) (multiple\?) (is-group)) cl-struct-soap-xs-complex-type-tags] 11)
#@72 Construct a `soap-xs-complex-type' by parsing the XML NODE.

(fn NODE)
(defalias 'soap-xs-parse-complex-type #[257 "\303
\304\"\303\305\"\306\211@\262
!\307\211\211\310>\204!\311\312\313\307C$\210\211AA\262
\211\203\306\211@\211:\203\277\306
\211@\262
!\211\314\267\210\202\277\315!B\262\210\202\277\316!B\262\210\202\277\317!\262\210\202\277\320!\262\210\202\277
\211AA\262
\211\203\271\211@\211:\203\262\306
\211@\262
!\211\321\267\210\202\262\315!B\262\210\202\262\316!B\262\210\202\262\322!\262	\210\202\262\320!\266\202\262\210
A\266\202\202o\266\202\277\210
A\266\202\202(\210\204\334\323\324\307\211\211\211\211\211\211\211\211\211\211&\f\262\325!>\204\353\326\327\330D\"\210\331I\210\325!>\204
\326\327\330D\"\210\332	I\210\325!>\204
\326\327\330D\"\210\333I\210\325!>\204)
\326\327\330D\"\210\334\335\325!>\204>
\326\327\330	D\"\210\334H\"I\210\325!>\204T
\326\327\330D\"\210\336\335\325!>\204i
\326\327\330	D\"\210\336H\"I\210\325!\n>\203\216
\325!\n>\204\207
\326\327\324D\"\210\337\340=I\210\207" [cl-struct-soap-xs-type-tags soap-target-xmlns cl-struct-soap-xs-complex-type-tags xml-get-attribute-or-nil name id soap-l2wk nil #1=(xsd:complexType xsd:complexContent xsd:group) cl--assertion-failed (memq node-name '#1#) "unexpected node: %s" #s(hash-table size 7 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (xsd:attribute 65 xsd:attributeGroup 76 xsd:simpleContent 87 xsd:sequence 96 xsd:all 96 xsd:choice 96 xsd:complexContent 105)) soap-xs-parse-attribute soap-xs-parse-attribute-group soap-xs-parse-simple-type soap-xs-parse-sequence #s(hash-table size 7 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (xsd:attribute 136 xsd:attributeGroup 148 xsd:extension 160 xsd:restriction 160 xsd:sequence 169 xsd:all 169 xsd:choice 169)) soap-xs-parse-extension-or-restriction record soap-xs-complex-type type-of signal wrong-type-argument soap-xs-type 1 2 3 4 append 5 11 xsd:group] 20 (#$ . 125754)])
#@89 Parse a sequence definition from XML NODE.
Returns a `soap-xs-complex-type'.

(fn NODE)
(defalias 'soap-xs-parse-sequence #[257 "\302
\211@\262
!\303>\204\304\305\306\307\302\211@\262
!C$\210\310\311\307\211\211\211\211\211\211\211\211\211\211&\f\312
!>\2048\313\314\311D\"\210\211\315\302\211@\262
!\211\316\267\202S\317\202\\\320\202\\\321\202\\\322\323\324#\205\\\307\262
I\210\312
!>\204o\313\314\311D\"\210\211\325\326!I\210\312
!>\204\205\313\314\311D\"\210\211\327\330!I\210
\211AA\262
\211\203F
\211@\211;\204?
\302
\211@\262
!\211\331\267\210\202?
\332!\312!>\204\276\313\314\311D\"\210\333\333HBI\266\202?
\334!\310\335\307\211\211\307\211\211\211\211\211&\312!>\204\356\313\314\311D\"\210\333\333HBI\266\202?
\336!\312!	>\204
\313\314\337D\"\210\340\340HBI\266\202?
\341!\312!	>\2040
\313\314\337D\"\210\342\342HBI\266\202?
\210
A\266\202\202\222\210\312
!>\204V
\313\314\311D\"\210\211\333\312!>\204g
\313\314\311D\"\210\333H\237I\210\207" [cl-struct-soap-xs-complex-type-tags cl-struct-soap-xs-type-tags soap-l2wk #1=(xsd:sequence xsd:choice xsd:all) cl--assertion-failed (memq (soap-l2wk (xml-node-name node)) '#1#) "unexpected node: %s" nil record soap-xs-complex-type type-of signal wrong-type-argument 6 #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (xsd:sequence 71 xsd:all 75 xsd:choice 79)) sequence all choice error "cl-ecase failed: %s, %s" (xsd:sequence xsd:all xsd:choice) 9 soap-node-optional 10 soap-node-multiple #s(hash-table size 7 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (xsd:element 171 xsd:group 171 xsd:sequence 204 xsd:choice 204 xsd:all 204 xsd:attribute 252 xsd:attributeGroup 285)) soap-xs-parse-element 8 soap-xs-parse-sequence soap-xs-element soap-xs-parse-attribute soap-xs-type 4 soap-xs-parse-attribute-group 5] 18 (#$ . 127802)])
#@105 Parse an extension or restriction definition from XML NODE.
Return a `soap-xs-complex-type'.

(fn NODE)
(defalias 'soap-xs-parse-extension-or-restriction #[257 "\301
\211@\262
!\302>\204\303\304\305\306\301\211@\262
!C$\210\306\211\211\211\307\310\"\301\211@\262
!\311=\2054\211\312\313!\232\262\211AA\262
\211\203\234\211@\211:\203\225\301
\211@\262
!\211\314\267\210\202\225\315!\262\210\202\225\203|\316\317\"\211\203w\320\321\"\203w\322\323\"\262\266\202\225\324!B\262\210\202\225\325!B\262\210\202\225\210
A\266\202\202<\210\204\313\326\327\306\211\211\211\211\211\211\211\211\211\211&\f\262
\203\313\330!>\204\306\331\332\327D\"\210\333\334I\210\330!>\204\333\331\332\327D\"\210\335\336!I\210\330!>\204\362\331\332\327D\"\210\337I\210\330!>\204
\331\332\327D\"\210\340I\210\207" [cl-struct-soap-xs-complex-type-tags soap-l2wk #1=(xsd:extension xsd:restriction) cl--assertion-failed (memq (soap-l2wk (xml-node-name node)) '#1#) "unexpected node: %s" nil xml-get-attribute-or-nil base xsd:restriction soap-wk2l "soapenc:Array" #s(hash-table size 5 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (xsd:sequence 85 xsd:choice 85 xsd:all 85 xsd:attribute 94 xsd:attributeGroup 136)) soap-xs-parse-sequence soap-xml-get-attribute-or-nil1 wsdl:arrayType string-match "^\\(.*\\)\\[\\]$" match-string 1 soap-xs-parse-attribute soap-xs-parse-attribute-group record soap-xs-complex-type type-of signal wrong-type-argument 6 array 7 soap-l2fq 4 5] 19 (#$ . 129717)])
#@212 Replace names in TYPE with the referenced objects in the WSDL.
This is a specialization of `soap-resolve-references' for
`soap-xs-complex-type' objects.

See also `soap-wsdl-resolve-references'.

(fn TYPE WSDL)
(defalias 'soap-resolve-references-for-xs-complex-type #[514 "\304!>\204\305\306\307D\"\210
\310H\211\2037\311
\312!\"@\211\2036\304!>\2041\305\306\307D\"\210\310I\210\210\210\304!	>\204G\305\306\313D\"\210
\314H\315
!\203l\304!	>\204_\305\306\313D\"\210\314\316\317#I\266\202z\304
!\n>\203y\320
\"\210\210\321\304!	>\204\212\305\306\313D\"\210\322H\211\203\377\211@\304
!>\204\242\305\306\323D\"\210\211\324H\203\356\316\304!>\204\270\305\306\323D\"\210
\314H\325#\304
!	>\204\315\305\306\313D\"\210\211\322H\211\203\351\211@\320
\"\210\211B\262
A\266\202\202\320\266\202\370\320
\"\210\211B\262
A\266\202\202\215\210\304!	>\204
\305\306\313D\"\210\322\237I\266\304!\n>\204%
\305\306\326D\"\210
\327H\211\203:
\211@\320
\"\210
A\266\202\202(
\210\304!\n>\204J
\305\306\326D\"\210
\330H\211\205_
\211@\320
\"\210
A\266\202\202M
\207" [cl-struct-soap-element-tags cl-struct-soap-xs-complex-type-tags cl-struct-soap-xs-type-tags cl-struct-soap-xs-element-tags type-of signal wrong-type-argument soap-element 2 rassoc soap-wsdl-alias-table soap-xs-complex-type 7 soap-name-p soap-wsdl-get soap-xs-type-p soap-resolve-references nil 8 soap-xs-element 10 #[257 "\301
!>\205\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-xs-complex-type-tags type-of signal wrong-type-argument soap-xs-complex-type 11] 5 "\n\n(fn TYPE)"] soap-xs-type 4 5] 11 (#$ . 131269)])
#@371 Encode the XML attributes for encoding VALUE according to TYPE.
The xsi:type and optional xsi:nil attributes are added, plus
additional attributes needed for arrays types, if applicable.  The
attributes are inserted in the current buffer at the current
position.

This is a specialization of `soap-encode-attributes' for
`soap-xs-complex-type' objects.

(fn VALUE TYPE)
(defalias 'soap-encode-xs-complex-type-attributes #[514 "\303
!>\204\304\305\306D\"\210\211\307H\310=\203<\303
!>\204&\304\305\306D\"\210\211\311H\312c\210\313\314!\315\316\317G\"\320\321\261\207\322
!\211\203\263\211@\303
!	>\204T\304\305\323D\"\210\211\324H\303!\n>\204f\304\305\325D\"\210
\326H\203\212\327
\330\303!\n>\204\304\305\325D\"\210\326H\321\261\266\202\254\211\203\252\211@\331@!\232\203\243\327\330A\321\261\210
A\266\202\202\213\266
A\266\202\202?\210\303
!>\204\303\304\305\306D\"\210\211\307H\205\320
?\205\320\332c\207" [cl-struct-soap-xs-complex-type-tags cl-struct-soap-element-tags cl-struct-soap-xs-attribute-tags type-of signal wrong-type-argument soap-xs-complex-type 6 array 7 " xsi:type=\"soapenc:Array\"" " soapenc:arrayType=\"" soap-element-fq-name "[" format "%s" "]" "\"" soap-get-xs-attributes soap-element 1 soap-xs-attribute 4 " " "=\"" symbol-name " xsi:nil=\"true\""] 12 (#$ . 132930)])
#@141 Return a list of elements that are compatible with ELEMENT.
The returned list includes ELEMENT's references and
alternatives.

(fn ELEMENT)
(defalias 'soap-get-candidate-elements #[257 "\301
!>\204\302\303\304D\"\210\211\305H\211\203-\306
C\301!>\204(\302\303\304D\"\210\307H\"\207\306C\301!>\204@\302\303\304D\"\210\307H\"\207" [cl-struct-soap-xs-element-tags type-of signal wrong-type-argument soap-xs-element 7 append 9] 8 (#$ . 134274)])
#@207 Encode the VALUE according to TYPE.
The data is inserted in the current buffer at the current
position.

This is a specialization of `soap-encode-value' for
`soap-xs-complex-type' objects.

(fn VALUE TYPE)
(defalias 'soap-encode-xs-complex-type #[514 "\302
!>\204\303\304\305D\"\210\211\306H\211\307\267\202Q\310\311!\207
C\312\302!>\204/\303\304\305D\"\210\313H\211\203R\211B\262\302
!>\204J\303\304\305D\"\210\211\313H\262
\2022\210
\211\203\216\211@\302
!>\204i\303\304\305D\"\210\211\314H\211\203\206\211@\211\235\204\315C\"\262
A\266\202\202l\210
A\266\202\202T\210\211\211\205P\211@\3162H\317\320!\211\203=
\211@\302
!	>\204\263\303\304\321D\"\210\211\322H\211\203\344\323
!\211\203\337\211@\211@\232\203\330T\262\324
A\"\210
A\266\202\202\277\266\2026
\302\n!>\204\365\303\304\305\fD\"\210	\306H\203
`\324\f\"\210\211`\232\204

T\262\266\2026
\n\211\2034
\211@`\324\"\210\211`\232\204,
T\262\210
A\266\202\202
\266
A\266\202\202\236\210\302!>\204O
\303\304\305	D\"\210\306H\325!\302!	>\204f
\303\304\321D\"\210\313H\302!	>\204y
\303\304\321D\"\210\322H\206\225
\211\205\225
\302
!	>\204\222
\303\304\321D\"\210\211\322H\326=\203\252
\317V\203\252
\327\316\330\"\266\204\202E\326=\204\317U\203\302!	>\204\307
\303\304\321D\"\210\331H\204\302!>\204\336
\303\304\305
D\"\210\n\332H\204\302!>\203\333!\204\334\fD\335\336\337\340#\341#\266\206\202E\322V\205C\302!	>\204\303\304\321D\"\210\306H?\205C\302!>\205C\342!?\205C\343\fD\335\336\337\340#\341#\266\202\266\204\262
0\210
A\266\202\202\220\207\310\344\302!>\204c\303\304\305D\"\210\306H\"\207" [cl-struct-soap-xs-complex-type-tags cl-struct-soap-xs-element-tags type-of signal wrong-type-argument soap-xs-complex-type 6 #s(hash-table size 5 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (array 24 sequence 28 choice 28 all 28 nil 28)) error "Arrays of type soap-encode-xs-complex-type are handled elsewhere" nil 7 8 append done 0 soap-get-candidate-elements soap-xs-element 1 intern soap-encode-value soap-xs-element-type choice throw t 5 9 soap-xs-complex-type-optional-p "While encoding %s: missing non-nillable slot %s" display-warning soap-client apply format :warning soap-xs-complex-type-multiple-p "While encoding %s: expected single, found multiple elements for slot %s" "Don't know how to encode complex type: %s"] 20 (#$ . 134740)])
#@187 Return the children of NODE named CHILD-NAME.
This is the same as `xml-get-children1', but NODE's local
namespace is used to resolve the children's namespace tags.

(fn NODE CHILD-NAME)
(defalias 'soap-xml-get-children-fq #[514 "\303\211AA\262
\211\203N\211@\211:\203G\304\"\211@\206	
A@\206#\n\3058\30618\307\211@\262
!0\202:\210\303\232+\262
\203G\211B\262
A\266\202\202\210\211\237\207" [soap-local-xmlns soap-default-xmlns soap-target-xmlns nil soap-extract-xmlns 2 (error) soap-l2fq] 10 (#$ . 137212)])
#@128 Return ELEMENT's fully-qualified name using WSDL's alias table.
Return nil if ELEMENT does not have a name.

(fn ELEMENT WSDL)
(defalias 'soap-xs-element-get-fq-name #[514 "\301
!\302\303!>\204\304\305\306D\"\210\307H\"A\211\2053\211\303!>\204/\304\305\306D\"\210\310HB\207" [cl-struct-soap-element-tags soap-wsdl-alias-table assoc type-of signal wrong-type-argument soap-element 2 1] 9 (#$ . 137748)])
#@96 Return t if TYPE or any of TYPE's ancestor types is optional.
Return nil otherwise.

(fn TYPE)
(defalias 'soap-xs-complex-type-optional-p #[257 "\211\2055\301
!>\204\302\303\304D\"\210\211\305H\2065\301
!>\2055\306\301!>\2041\302\303\304D\"\210
\307H!\207" [cl-struct-soap-xs-complex-type-tags type-of signal wrong-type-argument soap-xs-complex-type 9 soap-xs-complex-type-optional-p 7] 6 (#$ . 138172)])
#@110 Return t if TYPE or any of TYPE's ancestor types permits multiple elements.
Return nil otherwise.

(fn TYPE)
(defalias 'soap-xs-complex-type-multiple-p #[257 "\211\2055\301
!>\204\302\303\304D\"\210\211\305H\2065\301
!>\2055\306\301!>\2041\302\303\304D\"\210
\307H!\207" [cl-struct-soap-xs-complex-type-tags type-of signal wrong-type-argument soap-xs-complex-type 10 soap-xs-complex-type-multiple-p 7] 6 (#$ . 138596)])
#@79 Return a list of attributes from all ATTRIBUTE-GROUPS.

(fn ATTRIBUTE-GROUPS)
(defalias 'soap-get-xs-attributes-from-groups #[257 "\301
\211\203=\211@\302
!>\204\303\304\305D\"\210\211\306H\307\310!\302!>\204/\303\304\305D\"\210\311H#\262\210
A\266\202\202\210\207" [cl-struct-soap-xs-attribute-group-tags nil type-of signal wrong-type-argument soap-xs-attribute-group 5 append soap-get-xs-attributes-from-groups 4] 12 (#$ . 139034)])
#@77 Return a list of all of TYPE's and TYPE's ancestors' attributes.

(fn TYPE)
(defalias 'soap-get-xs-attributes #[257 "\302
!>\205\302
!>\204\303\304\305D\"\210\211\306H\307\302!	>\204*\303\304\310D\"\210\311H\312\302!	>\204>\303\304\310D\"\210\313H!\"
\203N\307
\314!\"\207\207" [cl-struct-soap-xs-complex-type-tags cl-struct-soap-xs-type-tags type-of signal wrong-type-argument soap-xs-complex-type 7 append soap-xs-type 4 soap-get-xs-attributes-from-groups 5 soap-get-xs-attributes] 9 (#$ . 139491)])
#@87 Use TYPE, a `soap-xs-complex-type', to decode the attributes of NODE.

(fn TYPE NODE)
(defalias 'soap-decode-xs-attributes #[514 "\303\304!\211\203\203\211@\305
!>\204\306\307\310D\"\210\211\311H\305!>\204+\306\307\310D\"\210
\312H\313!\314\"\305!	>\203U\211\203z
\315\303E\"BB\262\266\202|\305!\n>\203q\211\203z
\316\"BB\262\266\202|\317\320\321!#\210\266
A\266\202\202\210\207" [cl-struct-soap-xs-attribute-tags cl-struct-soap-xs-basic-type-tags cl-struct-soap-xs-simple-type-tags nil soap-get-xs-attributes type-of signal wrong-type-argument soap-xs-attribute 1 3 intern xml-get-attribute-or-nil soap-decode-xs-basic-type soap-validate-xs-simple-type error "Attribute %s is of type %s which is not a basic or simple type" soap-name-p] 15 (#$ . 140017)])
#@256 Use TYPE, a `soap-xs-complex-type', to decode the contents of NODE.
A LISP value is returned based on the contents of NODE and the
type-info stored in TYPE.

This is a specialization of `soap-decode-type' for
`soap-xs-basic-type' objects.

(fn TYPE NODE)
(defalias 'soap-decode-xs-complex-type #[514 "\303!>\204\304\305\306D\"\210
\307H\211\310\267\202\364
\311\303!>\204)\304\305\306D\"\210\312H\211AA\262
\211\203L\211@\211:\203E\313\"B\262
A\266\202\2022\210
\237\207\311\303!>\204a\304\305\306D\"\210\312H\211\203o\313
\"\237\262\3142\360
\303!>\204\203\304\305\306D\"\210\315H\211\205\355
\211@\316\303!	>\204\234\304\305\317D\"\210
\320H\321\322\323\n@!\"
\203\305\211\203\273\324	\325\n\"\"\202\310\326	\327!\"\202\310C\330!
\211\203
\211@T\262\331\"\332\333\"\203\360\334\335\332\333\"!\n\336\337$\202\361\313
\"\203

\327	!\340\"BB\262\266\202
\340
\"\262\266
A\266\202\202\314\210\303\f!>\204/
\304\305\306D\"\210\307H\341=\203N
\342\f!\204N
\316V\203N
\343\314\337\"\266\202\346
\303\f!>\204_
\304\305\306D\"\210\307H\341=\204\244
\316U\203\244
\303!	>\204
\304\305\317D\"\210\344H\204\244
\303
!>\203\244
\345
!\204\244
\346C\347\350\351\352#\353#\266\202\346
\320V\203\344
\342\f!\204\344
\303!	>\204\302
\304\305\317D\"\210\307H\204\344
\303
!>\203\344
\342
!\204\344
\354C\347\350\351\352#\353#\266\266
A\266\202\202\206\262
0\210
\237\207\355\356\303!>\204\304\305\306D\"\210\307H\"\207" [cl-struct-soap-xs-complex-type-tags cl-struct-soap-xs-element-tags soap-current-wsdl type-of signal wrong-type-argument soap-xs-complex-type 6 #s(hash-table size 5 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (array 24 sequence 80 choice 80 all 80 nil 80)) nil 7 soap-decode-type done 8 0 soap-xs-element 1 string-search ":" symbol-name soap-xml-get-children-fq soap-xs-element-get-fq-name xml-get-children intern soap-xs-element-type soap-decode-xs-attributes soap-xml-get-attribute-or-nil1 xsi:type soap-wsdl-get soap-l2fq soap-xs-type-p t append choice soap-xs-complex-type-multiple-p throw 5 soap-xs-complex-type-optional-p "missing non-nillable slot %s" display-warning soap-client apply format :warning "expected single %s slot, found multiple" error "Don't know how to decode complex type: %s"] 21 (#$ . 140822)])
(byte-code "\300\301\302\303\211\211\211\211\211\211\211\211\211\211&\f!\304
\305\306#\210\304
\307\310#\210\304
\311\312#\210\304
\313\314#\210\207" [soap-type-of record soap-xs-complex-type nil put soap-resolve-references soap-resolve-references-for-xs-complex-type soap-attribute-encoder soap-encode-xs-complex-type-attributes soap-encoder soap-encode-xs-complex-type soap-decoder soap-decode-xs-complex-type] 14)
#@71 compiler-macro for inlining `soap-message-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-message-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-message-p (and (memq (type-of cl-x) cl-struct-soap-message-tags) t)) nil] 9 (#$ . 143615)])
(put 'soap-message-p 'compiler-macro 'soap-message-p--cmacro)
#@13 

(fn CL-X)
(defalias 'soap-message-p #[257 "\301
!>\205	\302\207" [cl-struct-soap-message-tags type-of t] 3 (#$ . 143963)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put soap-message-p side-effect-free error-free put soap-message cl-deftype-satisfies] 5)
#@74 compiler-macro for inlining `soap-message-name'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-message-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-message-name (progn (or (soap-message-p cl-x) (signal 'wrong-type-argument (list 'soap-message cl-x))) (aref cl-x 1))) nil] 9 (#$ . 144247)])
(put 'soap-message-name 'compiler-macro 'soap-message-name--cmacro)
#@62 Access slot "name" of `soap-message' struct CL-X.

(fn CL-X)
(defalias 'soap-message-name #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-message-tags type-of signal wrong-type-argument soap-message 1] 5 (#$ . 144657)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-message-name side-effect-free t] 4)
#@83 compiler-macro for inlining `soap-message-namespace-tag'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-message-namespace-tag--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-message-namespace-tag (progn (or (soap-message-p cl-x) (signal 'wrong-type-argument (list 'soap-message cl-x))) (aref cl-x 2))) nil] 9 (#$ . 145001)])
(put 'soap-message-namespace-tag 'compiler-macro 'soap-message-namespace-tag--cmacro)
#@71 Access slot "namespace-tag" of `soap-message' struct CL-X.

(fn CL-X)
(defalias 'soap-message-namespace-tag #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-message-tags type-of signal wrong-type-argument soap-message 2] 5 (#$ . 145456)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-message-namespace-tag side-effect-free t] 4)
#@75 compiler-macro for inlining `soap-message-parts'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-message-parts--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-message-parts (progn (or (soap-message-p cl-x) (signal 'wrong-type-argument (list 'soap-message cl-x))) (aref cl-x 3))) nil] 9 (#$ . 145827)])
(put 'soap-message-parts 'compiler-macro 'soap-message-parts--cmacro)
#@63 Access slot "parts" of `soap-message' struct CL-X.

(fn CL-X)
(defalias 'soap-message-parts #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-message-tags type-of signal wrong-type-argument soap-message 3] 5 (#$ . 146242)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put soap-message-parts side-effect-free t defalias copy-soap-message copy-sequence] 4)
#@105 compiler-macro for inlining `make-soap-message'.

(fn CL-WHOLE &cl-quote &key NAME NAMESPACE-TAG PARTS)
(defalias 'make-soap-message--cmacro #[385 "\300
\301\"A@\300\302\"A@\300\303\"A@\211\203=\211@\304>\203&\211AA\262
\202\305>A@\2034\306\262
\202\307\310@\"\210\202\210\311\312\313\306\306&\207" [plist-member :name :namespace-tag :parts (:name :namespace-tag :parts :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag :parts)" cl--defsubst-expand (name namespace-tag parts) (cl-block make-soap-message (record 'soap-message name namespace-tag parts))] 14 (#$ . 146641)])
(put 'make-soap-message 'compiler-macro 'make-soap-message--cmacro)
#@85 Constructor for objects of type `soap-message'.

(fn &key NAME NAMESPACE-TAG PARTS)
(defalias 'make-soap-message #[128 "\300
\301\"A@\300\302\"A@\300\303\"A@\211\203=\211@\304>\203&\211AA\262
\202\305>A@\2034\306\262
\202\307\310@\"\210\202\210\311\312$\207" [plist-member :name :namespace-tag :parts (:name :namespace-tag :parts :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag :parts)" record soap-message] 9 (#$ . 147362)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put make-soap-message side-effect-free t cl-struct-define soap-message nil soap-element record ((cl-tag-slot) (name nil) (namespace-tag nil) (parts)) cl-struct-soap-message-tags] 11)
#@73 compiler-macro for inlining `soap-operation-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-operation-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-operation-p (and (memq (type-of cl-x) cl-struct-soap-operation-tags) t)) nil] 9 (#$ . 148134)])
(put 'soap-operation-p 'compiler-macro 'soap-operation-p--cmacro)
#@13 

(fn CL-X)
(defalias 'soap-operation-p #[257 "\301
!>\205	\302\207" [cl-struct-soap-operation-tags type-of t] 3 (#$ . 148494)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put soap-operation-p side-effect-free error-free put soap-operation cl-deftype-satisfies] 5)
#@76 compiler-macro for inlining `soap-operation-name'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-operation-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-operation-name (progn (or (soap-operation-p cl-x) (signal 'wrong-type-argument (list 'soap-operation cl-x))) (aref cl-x 1))) nil] 9 (#$ . 148786)])
(put 'soap-operation-name 'compiler-macro 'soap-operation-name--cmacro)
#@64 Access slot "name" of `soap-operation' struct CL-X.

(fn CL-X)
(defalias 'soap-operation-name #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-operation-tags type-of signal wrong-type-argument soap-operation 1] 5 (#$ . 149210)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-operation-name side-effect-free t] 4)
#@85 compiler-macro for inlining `soap-operation-namespace-tag'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-operation-namespace-tag--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-operation-namespace-tag (progn (or (soap-operation-p cl-x) (signal 'wrong-type-argument (list 'soap-operation cl-x))) (aref cl-x 2))) nil] 9 (#$ . 149564)])
(put 'soap-operation-namespace-tag 'compiler-macro 'soap-operation-namespace-tag--cmacro)
#@73 Access slot "namespace-tag" of `soap-operation' struct CL-X.

(fn CL-X)
(defalias 'soap-operation-namespace-tag #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-operation-tags type-of signal wrong-type-argument soap-operation 2] 5 (#$ . 150033)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-operation-namespace-tag side-effect-free t] 4)
#@87 compiler-macro for inlining `soap-operation-parameter-order'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-operation-parameter-order--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-operation-parameter-order (progn (or (soap-operation-p cl-x) (signal 'wrong-type-argument (list 'soap-operation cl-x))) (aref cl-x 3))) nil] 9 (#$ . 150414)])
(put 'soap-operation-parameter-order 'compiler-macro 'soap-operation-parameter-order--cmacro)
#@75 Access slot "parameter-order" of `soap-operation' struct CL-X.

(fn CL-X)
(defalias 'soap-operation-parameter-order #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-operation-tags type-of signal wrong-type-argument soap-operation 3] 5 (#$ . 150893)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-operation-parameter-order side-effect-free t] 4)
#@77 compiler-macro for inlining `soap-operation-input'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-operation-input--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-operation-input (progn (or (soap-operation-p cl-x) (signal 'wrong-type-argument (list 'soap-operation cl-x))) (aref cl-x 4))) nil] 9 (#$ . 151280)])
(put 'soap-operation-input 'compiler-macro 'soap-operation-input--cmacro)
#@65 Access slot "input" of `soap-operation' struct CL-X.

(fn CL-X)
(defalias 'soap-operation-input #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-operation-tags type-of signal wrong-type-argument soap-operation 4] 5 (#$ . 151709)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-operation-input side-effect-free t] 4)
#@78 compiler-macro for inlining `soap-operation-output'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-operation-output--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-operation-output (progn (or (soap-operation-p cl-x) (signal 'wrong-type-argument (list 'soap-operation cl-x))) (aref cl-x 5))) nil] 9 (#$ . 152066)])
(put 'soap-operation-output 'compiler-macro 'soap-operation-output--cmacro)
#@66 Access slot "output" of `soap-operation' struct CL-X.

(fn CL-X)
(defalias 'soap-operation-output #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-operation-tags type-of signal wrong-type-argument soap-operation 5] 5 (#$ . 152500)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-operation-output side-effect-free t] 4)
#@78 compiler-macro for inlining `soap-operation-faults'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-operation-faults--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-operation-faults (progn (or (soap-operation-p cl-x) (signal 'wrong-type-argument (list 'soap-operation cl-x))) (aref cl-x 6))) nil] 9 (#$ . 152860)])
(put 'soap-operation-faults 'compiler-macro 'soap-operation-faults--cmacro)
#@66 Access slot "faults" of `soap-operation' struct CL-X.

(fn CL-X)
(defalias 'soap-operation-faults #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-operation-tags type-of signal wrong-type-argument soap-operation 6] 5 (#$ . 153294)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-operation-faults side-effect-free t] 4)
#@84 compiler-macro for inlining `soap-operation-input-action'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-operation-input-action--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-operation-input-action (progn (or (soap-operation-p cl-x) (signal 'wrong-type-argument (list 'soap-operation cl-x))) (aref cl-x 7))) nil] 9 (#$ . 153654)])
(put 'soap-operation-input-action 'compiler-macro 'soap-operation-input-action--cmacro)
#@72 Access slot "input-action" of `soap-operation' struct CL-X.

(fn CL-X)
(defalias 'soap-operation-input-action #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-operation-tags type-of signal wrong-type-argument soap-operation 7] 5 (#$ . 154118)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-operation-input-action side-effect-free t] 4)
#@85 compiler-macro for inlining `soap-operation-output-action'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-operation-output-action--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-operation-output-action (progn (or (soap-operation-p cl-x) (signal 'wrong-type-argument (list 'soap-operation cl-x))) (aref cl-x 8))) nil] 9 (#$ . 154496)])
(put 'soap-operation-output-action 'compiler-macro 'soap-operation-output-action--cmacro)
#@73 Access slot "output-action" of `soap-operation' struct CL-X.

(fn CL-X)
(defalias 'soap-operation-output-action #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-operation-tags type-of signal wrong-type-argument soap-operation 8] 5 (#$ . 154965)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put soap-operation-output-action side-effect-free t defalias copy-soap-operation copy-sequence] 4)
#@164 compiler-macro for inlining `make-soap-operation'.

(fn CL-WHOLE &cl-quote &key NAME NAMESPACE-TAG PARAMETER-ORDER INPUT OUTPUT FAULTS INPUT-ACTION OUTPUT-ACTION)
(defalias 'make-soap-operation--cmacro #[385 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\300\306\"A@\300\307\"A@\300\310\"A@\211\203`\211@\311>\203H\211AA\262
\2025\312\n>A@\203W\313\262
\2025\314\315@\"\210\2025\210\316\317\320\313
\313







&
\207" [plist-member :name :namespace-tag :parameter-order :input :output :faults :input-action :output-action (:name :namespace-tag :parameter-order :input :output :faults :input-action :output-action :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag :parameter-order :input :output :faults :input-action :output-action)" cl--defsubst-expand (name namespace-tag parameter-order input output faults input-action output-action) (cl-block make-soap-operation (record 'soap-operation name namespace-tag parameter-order input output faults input-action output-action))] 24 (#$ . 155400)])
(put 'make-soap-operation 'compiler-macro 'make-soap-operation--cmacro)
#@144 Constructor for objects of type `soap-operation'.

(fn &key NAME NAMESPACE-TAG PARAMETER-ORDER INPUT OUTPUT FAULTS INPUT-ACTION OUTPUT-ACTION)
(defalias 'make-soap-operation #[128 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\300\306\"A@\300\307\"A@\300\310\"A@\211\203`\211@\311>\203H\211AA\262
\2025\312\n>A@\203W\313\262
\2025\314\315@\"\210\2025\210\316\317								&	\207" [plist-member :name :namespace-tag :parameter-order :input :output :faults :input-action :output-action (:name :namespace-tag :parameter-order :input :output :faults :input-action :output-action :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag :parameter-order :input :output :faults :input-action :output-action)" record soap-operation] 19 (#$ . 156572)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put make-soap-operation side-effect-free t cl-struct-define soap-operation nil soap-element record ((cl-tag-slot) (name nil) (namespace-tag nil) (parameter-order) (input) (output) (faults) (input-action) (output-action)) cl-struct-soap-operation-tags] 11)
#@73 compiler-macro for inlining `soap-port-type-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-port-type-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-port-type-p (and (memq (type-of cl-x) cl-struct-soap-port-type-tags) t)) nil] 9 (#$ . 157752)])
(put 'soap-port-type-p 'compiler-macro 'soap-port-type-p--cmacro)
#@13 

(fn CL-X)
(defalias 'soap-port-type-p #[257 "\301
!>\205	\302\207" [cl-struct-soap-port-type-tags type-of t] 3 (#$ . 158112)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put soap-port-type-p side-effect-free error-free put soap-port-type cl-deftype-satisfies] 5)
#@76 compiler-macro for inlining `soap-port-type-name'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-port-type-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-port-type-name (progn (or (soap-port-type-p cl-x) (signal 'wrong-type-argument (list 'soap-port-type cl-x))) (aref cl-x 1))) nil] 9 (#$ . 158404)])
(put 'soap-port-type-name 'compiler-macro 'soap-port-type-name--cmacro)
#@64 Access slot "name" of `soap-port-type' struct CL-X.

(fn CL-X)
(defalias 'soap-port-type-name #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-port-type-tags type-of signal wrong-type-argument soap-port-type 1] 5 (#$ . 158828)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-port-type-name side-effect-free t] 4)
#@85 compiler-macro for inlining `soap-port-type-namespace-tag'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-port-type-namespace-tag--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-port-type-namespace-tag (progn (or (soap-port-type-p cl-x) (signal 'wrong-type-argument (list 'soap-port-type cl-x))) (aref cl-x 2))) nil] 9 (#$ . 159182)])
(put 'soap-port-type-namespace-tag 'compiler-macro 'soap-port-type-namespace-tag--cmacro)
#@73 Access slot "namespace-tag" of `soap-port-type' struct CL-X.

(fn CL-X)
(defalias 'soap-port-type-namespace-tag #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-port-type-tags type-of signal wrong-type-argument soap-port-type 2] 5 (#$ . 159651)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-port-type-namespace-tag side-effect-free t] 4)
#@82 compiler-macro for inlining `soap-port-type-operations'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-port-type-operations--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-port-type-operations (progn (or (soap-port-type-p cl-x) (signal 'wrong-type-argument (list 'soap-port-type cl-x))) (aref cl-x 3))) nil] 9 (#$ . 160032)])
(put 'soap-port-type-operations 'compiler-macro 'soap-port-type-operations--cmacro)
#@70 Access slot "operations" of `soap-port-type' struct CL-X.

(fn CL-X)
(defalias 'soap-port-type-operations #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-port-type-tags type-of signal wrong-type-argument soap-port-type 3] 5 (#$ . 160486)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put soap-port-type-operations side-effect-free t defalias copy-soap-port-type copy-sequence] 4)
#@112 compiler-macro for inlining `make-soap-port-type'.

(fn CL-WHOLE &cl-quote &key NAME NAMESPACE-TAG OPERATIONS)
(defalias 'make-soap-port-type--cmacro #[385 "\300
\301\"A@\300\302\"A@\300\303\"A@\211\203=\211@\304>\203&\211AA\262
\202\305>A@\2034\306\262
\202\307\310@\"\210\202\210\311\312\313\306\306&\207" [plist-member :name :namespace-tag :operations (:name :namespace-tag :operations :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag :operations)" cl--defsubst-expand (name namespace-tag operations) (cl-block make-soap-port-type (record 'soap-port-type name namespace-tag operations))] 14 (#$ . 160912)])
(put 'make-soap-port-type 'compiler-macro 'make-soap-port-type--cmacro)
#@92 Constructor for objects of type `soap-port-type'.

(fn &key NAME NAMESPACE-TAG OPERATIONS)
(defalias 'make-soap-port-type #[128 "\300
\301\"A@\300\302\"A@\300\303\"A@\211\203=\211@\304>\203&\211AA\262
\202\305>A@\2034\306\262
\202\307\310@\"\210\202\210\311\312$\207" [plist-member :name :namespace-tag :operations (:name :namespace-tag :operations :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag :operations)" record soap-port-type] 9 (#$ . 161675)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put make-soap-port-type side-effect-free t cl-struct-define soap-port-type nil soap-element record ((cl-tag-slot) (name nil) (namespace-tag nil) (operations)) cl-struct-soap-port-type-tags] 11)
#@79 compiler-macro for inlining `soap-bound-operation-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-bound-operation-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-bound-operation-p (and (memq (type-of cl-x) cl-struct-soap-bound-operation-tags) t)) nil] 9 (#$ . 162484)])
(put 'soap-bound-operation-p 'compiler-macro 'soap-bound-operation-p--cmacro)
#@13 

(fn CL-X)
(defalias 'soap-bound-operation-p #[257 "\301
!>\205	\302\207" [cl-struct-soap-bound-operation-tags type-of t] 3 (#$ . 162880)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put soap-bound-operation-p side-effect-free error-free put soap-bound-operation cl-deftype-satisfies] 5)
#@87 compiler-macro for inlining `soap-bound-operation-operation'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-bound-operation-operation--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-bound-operation-operation (progn (or (soap-bound-operation-p cl-x) (signal 'wrong-type-argument (list 'soap-bound-operation cl-x))) (aref cl-x 1))) nil] 9 (#$ . 163196)])
(put 'soap-bound-operation-operation 'compiler-macro 'soap-bound-operation-operation--cmacro)
#@75 Access slot "operation" of `soap-bound-operation' struct CL-X.

(fn CL-X)
(defalias 'soap-bound-operation-operation #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-bound-operation-tags type-of signal wrong-type-argument soap-bound-operation 1] 5 (#$ . 163687)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-bound-operation-operation side-effect-free t] 4)
#@89 compiler-macro for inlining `soap-bound-operation-soap-action'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-bound-operation-soap-action--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-bound-operation-soap-action (progn (or (soap-bound-operation-p cl-x) (signal 'wrong-type-argument (list 'soap-bound-operation cl-x))) (aref cl-x 2))) nil] 9 (#$ . 164086)])
(put 'soap-bound-operation-soap-action 'compiler-macro 'soap-bound-operation-soap-action--cmacro)
#@77 Access slot "soap-action" of `soap-bound-operation' struct CL-X.

(fn CL-X)
(defalias 'soap-bound-operation-soap-action #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-bound-operation-tags type-of signal wrong-type-argument soap-bound-operation 2] 5 (#$ . 164587)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-bound-operation-soap-action side-effect-free t] 4)
#@90 compiler-macro for inlining `soap-bound-operation-soap-headers'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-bound-operation-soap-headers--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-bound-operation-soap-headers (progn (or (soap-bound-operation-p cl-x) (signal 'wrong-type-argument (list 'soap-bound-operation cl-x))) (aref cl-x 3))) nil] 9 (#$ . 164992)])
(put 'soap-bound-operation-soap-headers 'compiler-macro 'soap-bound-operation-soap-headers--cmacro)
#@78 Access slot "soap-headers" of `soap-bound-operation' struct CL-X.

(fn CL-X)
(defalias 'soap-bound-operation-soap-headers #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-bound-operation-tags type-of signal wrong-type-argument soap-bound-operation 3] 5 (#$ . 165498)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-bound-operation-soap-headers side-effect-free t] 4)
#@87 compiler-macro for inlining `soap-bound-operation-soap-body'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-bound-operation-soap-body--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-bound-operation-soap-body (progn (or (soap-bound-operation-p cl-x) (signal 'wrong-type-argument (list 'soap-bound-operation cl-x))) (aref cl-x 4))) nil] 9 (#$ . 165906)])
(put 'soap-bound-operation-soap-body 'compiler-macro 'soap-bound-operation-soap-body--cmacro)
#@75 Access slot "soap-body" of `soap-bound-operation' struct CL-X.

(fn CL-X)
(defalias 'soap-bound-operation-soap-body #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-bound-operation-tags type-of signal wrong-type-argument soap-bound-operation 4] 5 (#$ . 166397)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-bound-operation-soap-body side-effect-free t] 4)
#@81 compiler-macro for inlining `soap-bound-operation-use'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-bound-operation-use--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-bound-operation-use (progn (or (soap-bound-operation-p cl-x) (signal 'wrong-type-argument (list 'soap-bound-operation cl-x))) (aref cl-x 5))) nil] 9 (#$ . 166796)])
(put 'soap-bound-operation-use 'compiler-macro 'soap-bound-operation-use--cmacro)
#@69 Access slot "use" of `soap-bound-operation' struct CL-X.

(fn CL-X)
(defalias 'soap-bound-operation-use #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-bound-operation-tags type-of signal wrong-type-argument soap-bound-operation 5] 5 (#$ . 167257)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put soap-bound-operation-use side-effect-free t defalias copy-soap-bound-operation copy-sequence] 4)
#@137 compiler-macro for inlining `make-soap-bound-operation'.

(fn CL-WHOLE &cl-quote &key OPERATION SOAP-ACTION SOAP-HEADERS SOAP-BODY USE)
(defalias 'make-soap-bound-operation--cmacro #[385 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\211\203J\211@\306>\2032\211AA\262
\202\307>A@\203A\310\262
\202\311\312@\"\210\202\210\313\314\315\310\n\310\n\n\n\n\n&\n\207" [plist-member :operation :soap-action :soap-headers :soap-body :use (:operation :soap-action :soap-headers :soap-body :use :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:operation :soap-action :soap-headers :soap-body :use)" cl--defsubst-expand (operation soap-action soap-headers soap-body use) (cl-block make-soap-bound-operation (record 'soap-bound-operation operation soap-action soap-headers soap-body use))] 18 (#$ . 167698)])
(put 'make-soap-bound-operation 'compiler-macro 'make-soap-bound-operation--cmacro)
#@117 Constructor for objects of type `soap-bound-operation'.

(fn &key OPERATION SOAP-ACTION SOAP-HEADERS SOAP-BODY USE)
(defalias 'make-soap-bound-operation #[128 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\211\203J\211@\306>\2032\211AA\262
\202\307>A@\203A\310\262
\202\311\312@\"\210\202\210\313\314&\207" [plist-member :operation :soap-action :soap-headers :soap-body :use (:operation :soap-action :soap-headers :soap-body :use :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:operation :soap-action :soap-headers :soap-body :use)" record soap-bound-operation] 13 (#$ . 168656)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put make-soap-bound-operation side-effect-free t cl-struct-define soap-bound-operation nil cl-structure-object record ((cl-tag-slot) (operation) (soap-action) (soap-headers) (soap-body) (use)) cl-struct-soap-bound-operation-tags] 11)
#@71 compiler-macro for inlining `soap-binding-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-binding-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-binding-p (and (memq (type-of cl-x) cl-struct-soap-binding-tags) t)) nil] 9 (#$ . 169641)])
(put 'soap-binding-p 'compiler-macro 'soap-binding-p--cmacro)
#@13 

(fn CL-X)
(defalias 'soap-binding-p #[257 "\301
!>\205	\302\207" [cl-struct-soap-binding-tags type-of t] 3 (#$ . 169989)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put soap-binding-p side-effect-free error-free put soap-binding cl-deftype-satisfies] 5)
#@74 compiler-macro for inlining `soap-binding-name'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-binding-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-binding-name (progn (or (soap-binding-p cl-x) (signal 'wrong-type-argument (list 'soap-binding cl-x))) (aref cl-x 1))) nil] 9 (#$ . 170273)])
(put 'soap-binding-name 'compiler-macro 'soap-binding-name--cmacro)
#@62 Access slot "name" of `soap-binding' struct CL-X.

(fn CL-X)
(defalias 'soap-binding-name #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-binding-tags type-of signal wrong-type-argument soap-binding 1] 5 (#$ . 170683)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-binding-name side-effect-free t] 4)
#@83 compiler-macro for inlining `soap-binding-namespace-tag'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-binding-namespace-tag--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-binding-namespace-tag (progn (or (soap-binding-p cl-x) (signal 'wrong-type-argument (list 'soap-binding cl-x))) (aref cl-x 2))) nil] 9 (#$ . 171027)])
(put 'soap-binding-namespace-tag 'compiler-macro 'soap-binding-namespace-tag--cmacro)
#@71 Access slot "namespace-tag" of `soap-binding' struct CL-X.

(fn CL-X)
(defalias 'soap-binding-namespace-tag #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-binding-tags type-of signal wrong-type-argument soap-binding 2] 5 (#$ . 171482)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-binding-namespace-tag side-effect-free t] 4)
#@79 compiler-macro for inlining `soap-binding-port-type'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-binding-port-type--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-binding-port-type (progn (or (soap-binding-p cl-x) (signal 'wrong-type-argument (list 'soap-binding cl-x))) (aref cl-x 3))) nil] 9 (#$ . 171853)])
(put 'soap-binding-port-type 'compiler-macro 'soap-binding-port-type--cmacro)
#@67 Access slot "port-type" of `soap-binding' struct CL-X.

(fn CL-X)
(defalias 'soap-binding-port-type #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-binding-tags type-of signal wrong-type-argument soap-binding 3] 5 (#$ . 172288)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-binding-port-type side-effect-free t] 4)
#@80 compiler-macro for inlining `soap-binding-operations'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-binding-operations--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-binding-operations (progn (or (soap-binding-p cl-x) (signal 'wrong-type-argument (list 'soap-binding cl-x))) (aref cl-x 4))) nil] 9 (#$ . 172647)])
(put 'soap-binding-operations 'compiler-macro 'soap-binding-operations--cmacro)
#@68 Access slot "operations" of `soap-binding' struct CL-X.

(fn CL-X)
(defalias 'soap-binding-operations #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-binding-tags type-of signal wrong-type-argument soap-binding 4] 5 (#$ . 173087)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put soap-binding-operations side-effect-free t defalias copy-soap-binding copy-sequence] 4)
#@120 compiler-macro for inlining `make-soap-binding'.

(fn CL-WHOLE &cl-quote &key NAME NAMESPACE-TAG PORT-TYPE OPERATIONS)
(defalias 'make-soap-binding--cmacro #[385 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"\206\305A@\211\203H\211@\306>\2030\211AA\262
\202\307>A@\203?\310\262
\202\311\312@\"\210\202\210\313\314\315\310	\310				&	\207" [plist-member :name :namespace-tag :port-type :operations (nil (make-hash-table :test 'equal)) (:name :namespace-tag :port-type :operations :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag :port-type :operations)" cl--defsubst-expand (name namespace-tag port-type operations) (cl-block make-soap-binding (record 'soap-binding name namespace-tag port-type operations))] 16 (#$ . 173501)])
(put 'make-soap-binding 'compiler-macro 'make-soap-binding--cmacro)
#@100 Constructor for objects of type `soap-binding'.

(fn &key NAME NAMESPACE-TAG PORT-TYPE OPERATIONS)
(defalias 'make-soap-binding #[128 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"\206\305\306\307\310\"DA@\211\203M\211@\311>\2035\211AA\262
\202\"\312>A@\203D\305\262
\202\"\313\314@\"\210\202\"\210\315\316%\207" [plist-member :name :namespace-tag :port-type :operations nil make-hash-table :test equal (:name :namespace-tag :port-type :operations :allow-other-keys) :allow-other-keys error "Keyword argument %s not one of (:name :namespace-tag :port-type :operations)" record soap-binding] 11 (#$ . 174379)])
(cl-struct-define 'soap-binding nil 'soap-element 'record nil '((cl-tag-slot) (name nil) (namespace-tag nil) (port-type) (operations (make-hash-table :test 'equal) :readonly t)) 'cl-struct-soap-binding-tags 'soap-binding t)
#@68 compiler-macro for inlining `soap-port-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-port-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-port-p (and (memq (type-of cl-x) cl-struct-soap-port-tags) t)) nil] 9 (#$ . 175240)])
(put 'soap-port-p 'compiler-macro 'soap-port-p--cmacro)
#@13 

(fn CL-X)
(defalias 'soap-port-p #[257 "\301
!>\205	\302\207" [cl-struct-soap-port-tags type-of t] 3 (#$ . 175570)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put soap-port-p side-effect-free error-free put soap-port cl-deftype-satisfies] 5)
#@71 compiler-macro for inlining `soap-port-name'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-port-name--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-port-name (progn (or (soap-port-p cl-x) (signal 'wrong-type-argument (list 'soap-port cl-x))) (aref cl-x 1))) nil] 9 (#$ . 175842)])
(put 'soap-port-name 'compiler-macro 'soap-port-name--cmacro)
#@59 Access slot "name" of `soap-port' struct CL-X.

(fn CL-X)
(defalias 'soap-port-name #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-port-tags type-of signal wrong-type-argument soap-port 1] 5 (#$ . 176231)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-port-name side-effect-free t] 4)
#@80 compiler-macro for inlining `soap-port-namespace-tag'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-port-namespace-tag--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-port-namespace-tag (progn (or (soap-port-p cl-x) (signal 'wrong-type-argument (list 'soap-port cl-x))) (aref cl-x 2))) nil] 9 (#$ . 176560)])
(put 'soap-port-namespace-tag 'compiler-macro 'soap-port-namespace-tag--cmacro)
#@68 Access slot "namespace-tag" of `soap-port' struct CL-X.

(fn CL-X)
(defalias 'soap-port-namespace-tag #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-port-tags type-of signal wrong-type-argument soap-port 2] 5 (#$ . 176994)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-port-namespace-tag side-effect-free t] 4)
#@78 compiler-macro for inlining `soap-port-service-url'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-port-service-url--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-port-service-url (progn (or (soap-port-p cl-x) (signal 'wrong-type-argument (list 'soap-port cl-x))) (aref cl-x 3))) nil] 9 (#$ . 177350)])
(put 'soap-port-service-url 'compiler-macro 'soap-port-service-url--cmacro)
#@66 Access slot "service-url" of `soap-port' struct CL-X.

(fn CL-X)
(defalias 'soap-port-service-url #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-port-tags type-of signal wrong-type-argument soap-port 3] 5 (#$ . 177774)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-port-service-url side-effect-free t] 4)
#@74 compiler-macro for inlining `soap-port-binding'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-port-binding--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-port-binding (progn (or (soap-port-p cl-x) (signal 'wrong-type-argument (list 'soap-port cl-x))) (aref cl-x 4))) nil] 9 (#$ . 178124)])
(put 'soap-port-binding 'compiler-macro 'soap-port-binding--cmacro)
#@62 Access slot "binding" of `soap-port' struct CL-X.

(fn CL-X)
(defalias 'soap-port-binding #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-port-tags type-of signal wrong-type-argument soap-port 4] 5 (#$ . 178528)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put soap-port-binding side-effect-free t defalias copy-soap-port copy-sequence] 4)
#@116 compiler-macro for inlining `make-soap-port'.

(fn CL-WHOLE &cl-quote &key NAME NAMESPACE-TAG SERVICE-URL BINDING)
(defalias 'make-soap-port--cmacro #[385 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\211\203D\211@\305>\203,\211AA\262
\202\306>A@\203;\307\262
\202\310\311@\"\210\202\210\312\313\314\307	\307				&	\207" [plist-member :name :namespace-tag :service-url :binding (:name :namespace-tag :service-url :binding :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag :service-url :binding)" cl--defsubst-expand (name namespace-tag service-url binding) (cl-block make-soap-port (record 'soap-port name namespace-tag service-url binding))] 16 (#$ . 178915)])
(put 'make-soap-port 'compiler-macro 'make-soap-port--cmacro)
#@96 Constructor for objects of type `soap-port'.

(fn &key NAME NAMESPACE-TAG SERVICE-URL BINDING)
(defalias 'make-soap-port #[128 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\211\203D\211@\305>\203,\211AA\262
\202\306>A@\203;\307\262
\202\310\311@\"\210\202\210\312\313%\207" [plist-member :name :namespace-tag :service-url :binding (:name :namespace-tag :service-url :binding :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:name :namespace-tag :service-url :binding)" record soap-port] 11 (#$ . 179721)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put make-soap-port side-effect-free t cl-struct-define soap-port nil soap-element record ((cl-tag-slot) (name nil) (namespace-tag nil) (service-url) (binding)) cl-struct-soap-port-tags] 11)
#@68 compiler-macro for inlining `soap-wsdl-p'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-wsdl-p--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-wsdl-p (and (memq (type-of cl-x) cl-struct-soap-wsdl-tags) t)) nil] 9 (#$ . 180566)])
(put 'soap-wsdl-p 'compiler-macro 'soap-wsdl-p--cmacro)
#@13 

(fn CL-X)
(defalias 'soap-wsdl-p #[257 "\301
!>\205	\302\207" [cl-struct-soap-wsdl-tags type-of t] 3 (#$ . 180896)])
(byte-code "\300\301\302\303#\304\305\306\301#\207" [function-put soap-wsdl-p side-effect-free error-free put soap-wsdl cl-deftype-satisfies] 5)
#@73 compiler-macro for inlining `soap-wsdl-origin'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-wsdl-origin--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-wsdl-origin (progn (or (soap-wsdl-p cl-x) (signal 'wrong-type-argument (list 'soap-wsdl cl-x))) (aref cl-x 1))) nil] 9 (#$ . 181168)])
(put 'soap-wsdl-origin 'compiler-macro 'soap-wsdl-origin--cmacro)
#@61 Access slot "origin" of `soap-wsdl' struct CL-X.

(fn CL-X)
(defalias 'soap-wsdl-origin #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-wsdl-tags type-of signal wrong-type-argument soap-wsdl 1] 5 (#$ . 181567)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-wsdl-origin side-effect-free t] 4)
#@79 compiler-macro for inlining `soap-wsdl-current-file'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-wsdl-current-file--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-wsdl-current-file (progn (or (soap-wsdl-p cl-x) (signal 'wrong-type-argument (list 'soap-wsdl cl-x))) (aref cl-x 2))) nil] 9 (#$ . 181902)])
(put 'soap-wsdl-current-file 'compiler-macro 'soap-wsdl-current-file--cmacro)
#@67 Access slot "current-file" of `soap-wsdl' struct CL-X.

(fn CL-X)
(defalias 'soap-wsdl-current-file #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-wsdl-tags type-of signal wrong-type-argument soap-wsdl 2] 5 (#$ . 182331)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-wsdl-current-file side-effect-free t] 4)
#@84 compiler-macro for inlining `soap-wsdl-xmlschema-imports'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-wsdl-xmlschema-imports--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-wsdl-xmlschema-imports (progn (or (soap-wsdl-p cl-x) (signal 'wrong-type-argument (list 'soap-wsdl cl-x))) (aref cl-x 3))) nil] 9 (#$ . 182684)])
(put 'soap-wsdl-xmlschema-imports 'compiler-macro 'soap-wsdl-xmlschema-imports--cmacro)
#@72 Access slot "xmlschema-imports" of `soap-wsdl' struct CL-X.

(fn CL-X)
(defalias 'soap-wsdl-xmlschema-imports #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-wsdl-tags type-of signal wrong-type-argument soap-wsdl 3] 5 (#$ . 183138)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-wsdl-xmlschema-imports side-effect-free t] 4)
#@72 compiler-macro for inlining `soap-wsdl-ports'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-wsdl-ports--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-wsdl-ports (progn (or (soap-wsdl-p cl-x) (signal 'wrong-type-argument (list 'soap-wsdl cl-x))) (aref cl-x 4))) nil] 9 (#$ . 183506)])
(put 'soap-wsdl-ports 'compiler-macro 'soap-wsdl-ports--cmacro)
#@60 Access slot "ports" of `soap-wsdl' struct CL-X.

(fn CL-X)
(defalias 'soap-wsdl-ports #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-wsdl-tags type-of signal wrong-type-argument soap-wsdl 4] 5 (#$ . 183900)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-wsdl-ports side-effect-free t] 4)
#@78 compiler-macro for inlining `soap-wsdl-alias-table'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-wsdl-alias-table--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-wsdl-alias-table (progn (or (soap-wsdl-p cl-x) (signal 'wrong-type-argument (list 'soap-wsdl cl-x))) (aref cl-x 5))) nil] 9 (#$ . 184232)])
(put 'soap-wsdl-alias-table 'compiler-macro 'soap-wsdl-alias-table--cmacro)
#@66 Access slot "alias-table" of `soap-wsdl' struct CL-X.

(fn CL-X)
(defalias 'soap-wsdl-alias-table #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-wsdl-tags type-of signal wrong-type-argument soap-wsdl 5] 5 (#$ . 184656)])
(byte-code "\300\301\302\303#\300\207" [function-put soap-wsdl-alias-table side-effect-free t] 4)
#@77 compiler-macro for inlining `soap-wsdl-namespaces'.

(fn CL-WHOLE-ARG CL-X)
(defalias 'soap-wsdl-namespaces--cmacro #[514 "\300\301\302\303\211\211&\207" [cl--defsubst-expand (cl-x) (cl-block soap-wsdl-namespaces (progn (or (soap-wsdl-p cl-x) (signal 'wrong-type-argument (list 'soap-wsdl cl-x))) (aref cl-x 6))) nil] 9 (#$ . 185006)])
(put 'soap-wsdl-namespaces 'compiler-macro 'soap-wsdl-namespaces--cmacro)
#@65 Access slot "namespaces" of `soap-wsdl' struct CL-X.

(fn CL-X)
(defalias 'soap-wsdl-namespaces #[257 "\301
!>\204\302\303\304D\"\210\211\305H\207" [cl-struct-soap-wsdl-tags type-of signal wrong-type-argument soap-wsdl 6] 5 (#$ . 185425)])
(byte-code "\300\301\302\303#\304\305\306\"\207" [function-put soap-wsdl-namespaces side-effect-free t defalias soap-copy-wsdl copy-sequence] 4)
#@145 compiler-macro for inlining `soap-make-wsdl^'.

(fn CL-WHOLE &cl-quote &key ORIGIN CURRENT-FILE XMLSCHEMA-IMPORTS PORTS ALIAS-TABLE NAMESPACES)
(defalias 'soap-make-wsdl^--cmacro #[385 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\300\306\"A@\211\203R\211@\307>\203:\211AA\262
\202'\310>A@\203I\311\262
\202'\312\313@\"\210\202'\210\314\315\316\311\311&\207" [plist-member :origin :current-file :xmlschema-imports :ports :alias-table :namespaces (:origin :current-file :xmlschema-imports :ports :alias-table :namespaces :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:origin :current-file :xmlschema-imports :ports :alias-table :namespaces)" cl--defsubst-expand (origin current-file xmlschema-imports ports alias-table namespaces) (cl-block soap-make-wsdl^ (record 'soap-wsdl origin current-file xmlschema-imports ports alias-table namespaces))] 20 (#$ . 185821)])
(put 'soap-make-wsdl^ 'compiler-macro 'soap-make-wsdl^--cmacro)
#@124 Constructor for objects of type `soap-wsdl'.

(fn &key ORIGIN CURRENT-FILE XMLSCHEMA-IMPORTS PORTS ALIAS-TABLE NAMESPACES)
(defalias 'soap-make-wsdl^ #[128 "\300
\301\"A@\300\302\"A@\300\303\"A@\300\304\"A@\300\305\"A@\300\306\"A@\211\203R\211@\307>\203:\211AA\262
\202'\310>A@\203I\311\262
\202'\312\313@\"\210\202'\210\314\315&\207" [plist-member :origin :current-file :xmlschema-imports :ports :alias-table :namespaces (:origin :current-file :xmlschema-imports :ports :alias-table :namespaces :allow-other-keys) :allow-other-keys nil error "Keyword argument %s not one of (:origin :current-file :xmlschema-imports :ports :alias-table :namespaces)" record soap-wsdl] 15 (#$ . 186839)])
(byte-code "\300\301\302\303#\304\305\306\307\310\306\311\312\305\303&	\207" [function-put soap-make-wsdl^ side-effect-free t cl-struct-define soap-wsdl nil cl-structure-object record ((cl-tag-slot) (origin) (current-file) (xmlschema-imports) (ports) (alias-table) (namespaces)) cl-struct-soap-wsdl-tags] 11)
#@81 Create a new WSDL document, loaded from ORIGIN, and initialize it.

(fn ORIGIN)
(defalias 'soap-make-wsdl #[257 "\301\302\303\211\211\211\211&\304\305\306\"\307
\"\210\310\306\311!>\204$\312\313\314D\"\210\315H#\266\304\316\317\"\307
\"\210\310\317\311!>\204E\312\313\314D\"\210\315H#\266\207" [cl-struct-soap-namespace-tags record soap-wsdl nil soap-make-xs-basic-types "http://www.w3.org/2001/XMLSchema" "xsd" soap-wsdl-add-namespace soap-wsdl-add-alias type-of signal wrong-type-argument soap-namespace 1 "http://schemas.xmlsoap.org/soap/encoding/" "soapenc"] 9 (#$ . 187872)])
#@76 Add a namespace ALIAS for NAME to the WSDL document.

(fn ALIAS NAME WSDL)
(defalias 'soap-wsdl-add-alias #[771 "\301\302!>\204\303\304\305D\"\210\306H\"\211\203E\211A\232?\205a\307\310A$\210B\302!>\204<\303\304\305D\"\210\306\306HBI\207B\302!>\204W\303\304\305D\"\210\306\306HBI\262
\207" [cl-struct-soap-wsdl-tags assoc type-of signal wrong-type-argument soap-wsdl 5 warn "Redefining alias %s from %s to %s"] 10 (#$ . 188477)])
#@64 Find a namespace by NAME in the WSDL document.

(fn NAME WSDL)
(defalias 'soap-wsdl-find-namespace #[514 "\3022B\303
!>\204\304\305\306D\"\210\211\307H\211\205?\211@\303!	>\204,\304\305\310D\"\210
\311H\232\2038\312\302\"\210
A\266\202\202\262
0\207" [cl-struct-soap-wsdl-tags cl-struct-soap-namespace-tags found type-of signal wrong-type-argument soap-wsdl 6 soap-namespace 1 throw] 9 (#$ . 188945)])
#@151 Add the namespace NS to the WSDL document.
If a namespace by this name already exists in WSDL, individual
elements will be added to it.

(fn NS WSDL)
(defalias 'soap-wsdl-add-namespace #[514 "\302\303!>\204\304\305\306D\"\210\307H\"\211\2033\310\311\312\"\303!>\204.\304\305\306D\"\210\313H\"\207\303!	>\204B\304\305\314D\"\210
\315\315HBI\207" [cl-struct-soap-namespace-tags cl-struct-soap-wsdl-tags soap-wsdl-find-namespace type-of signal wrong-type-argument soap-namespace 1 maphash make-closure #[514 "\211\211\205\211@\301
\300\"\210
A\266\202\202
\207" [V0 soap-namespace-put] 7 "\n\n(fn KEY VALUE)"] 2 soap-wsdl 6] 9 (#$ . 189368)])
#@562 Retrieve element NAME from the WSDL document.

PREDICATE is used to differentiate between elements when NAME
refers to multiple elements.  A typical value for this would be a
structure predicate for the type of element you want to retrieve.
For example, to retrieve a message named "foo" when other
elements named "foo" exist in the WSDL you could use:

  (soap-wsdl-get "foo" WSDL \='soap-message-p)

If USE-LOCAL-ALIAS-TABLE is not nil, `soap-local-xmlns' will be
used to resolve the namespace alias.

(fn NAME WSDL &optional PREDICATE USE-LOCAL-ALIAS-TABLE)
(defalias 'soap-wsdl-get #[1026 "\303!>\204\304\305\306D\"\210\307H\310\211\2119\203!\311!\262\203+\312	\"\262:\203WA\262
9\203@\311!\262\313@\"\262\204\232\314\315	#\210\202\232\316\317	\"\203\224\320\321	\"\262\320\322	\"\323
\"A\211\204|\314\324#\210\313
\n\"\262\204\217\314\325$\210\266\202\232\314\326	\"\210\327\205\247\330\331\n\"#\262
\211\204\264\314\332	\"\210\303
!\n>\203\325\333\303!\n>\204\314\304\305\334D\"\210
\335H#\207\207" [cl-struct-soap-wsdl-tags soap-local-xmlns cl-struct-soap-namespace-link-tags type-of signal wrong-type-argument soap-wsdl 5 nil symbol-name append soap-wsdl-find-namespace error "Soap-wsdl-get(%s): unknown namespace: %s" string-match "^\\(.*\\):\\(.*\\)$" match-string 2 1 assoc "Soap-wsdl-get(%s): cannot find namespace alias %s" "Soap-wsdl-get(%s): unknown namespace %s, referenced as %s" "Soap-wsdl-get(%s): bad name" soap-namespace-get make-closure #[257 "\301
!\206	\300
!\207" [V0 soap-namespace-link-p] 3 "\n\n(fn E)"] "Soap-wsdl-get(%s): cannot find element" soap-wsdl-get soap-namespace-link 3] 15 (#$ . 190038)])
#@116 Parse a schema NODE, placing the results in WSDL.
Return a SOAP-NAMESPACE containing the elements.

(fn NODE WSDL)
(defalias 'soap-parse-schema #[514 "\304\"\211@\206\n	
A@\206\n\3058\306\211@\262
!\307=\2042\310\311\312\313\306\211@\262
!C$\210\314\315\316!\"\211AA\262
\211\203\306\211@\211;\204\277\306
\211@\262
!\211\317\267\210\202\277\320\321\"\206b\320\322\"\211\203\202\323!>\204w\324\325\326	D\"\210\327	\327HBI\210\266\202\277\330\331!\"\266\202\277\330\332!\"\266\202\277\330\333!\"\266\202\277\330\334!\"\266\202\277\330\335!\"\266\202\277\210
A\266\202\202>\210\211\262
+\207" [soap-local-xmlns soap-default-xmlns soap-target-xmlns cl-struct-soap-wsdl-tags soap-extract-xmlns 2 soap-l2wk xsd:schema cl--assertion-failed (eq (soap-l2wk (xml-node-name node)) 'xsd:schema) "expecting an xsd:schema node, got %s" nil make-soap-namespace :name soap-get-target-namespace #s(hash-table size 7 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (xsd:import 87 xsd:element 135 xsd:attribute 146 xsd:attributeGroup 157 xsd:simpleType 168 xsd:complexType 179 xsd:group 179)) xml-get-attribute-or-nil schemaLocation location type-of signal wrong-type-argument soap-wsdl 3 soap-namespace-put soap-xs-parse-element soap-xs-parse-attribute soap-xs-parse-attribute-group soap-xs-parse-simple-type soap-xs-parse-complex-type] 13 (#$ . 191748)])
#@256 Replace names in ELEMENT with the referenced objects in the WSDL.
This is a generic function which invokes a specific resolver
function depending on the type of the ELEMENT.

If ELEMENT has no resolver function, it is silently ignored.

(fn ELEMENT WSDL)
(defalias 'soap-resolve-references #[514 "\300!\301N\211\205
\211\"\207" [soap-type-of soap-resolve-references] 6 (#$ . 193164)])
#@231 Replace names in MESSAGE with the referenced objects in the WSDL.
This is a generic function, called by `soap-resolve-references',
you should use that function instead.

See also `soap-wsdl-resolve-references'.

(fn MESSAGE WSDL)
(defalias 'soap-resolve-references-for-message #[514 "\302\303!>\204\304\305\306D\"\210\307H\211\203\213\211@\211@
A
;\203'\310!\262\311
!\2038\312
\313#\262
\202{\314
\"\210\303
!	>\204M\304\305\315D\"\210\211\316H\204{\303
!	>\204b\304\305\315D\"\210\211\316\303	!	>\204u\304\305\315D\"\210\316HI\210

BB\262\266
A\266\202\202\210\303!>\204\233\304\305\306D\"\210\307\237I\207" [cl-struct-soap-message-tags cl-struct-soap-element-tags nil type-of signal wrong-type-argument soap-message 3 intern soap-name-p soap-wsdl-get #[257 "\302
!>\203\n\303\207\302
!	>\205\303\207" [cl-struct-soap-xs-type-tags cl-struct-soap-xs-element-tags type-of t] 3 "\n\n(fn X)"] soap-resolve-references soap-element 2] 13 (#$ . 193560)])
#@158 Resolve references for an OPERATION type using the WSDL document.
See also `soap-resolve-references' and
`soap-wsdl-resolve-references'

(fn OPERATION WSDL)
(defalias 'soap-resolve-references-for-operation #[514 "\304!>\204\305\306\307D\"\210
\310H\211\203G\311
\304!	>\204(\305\306\312D\"\210\313H\"@\211\203F\304!>\204A\305\306\307D\"\210\310I\210\210\210\304!\n>\204W\305\306\314D\"\210
\315H\316
@A
\203i
\317\232\203r\320\321\322\211\262\"\262\323
!\203\227\304!\n>\204\211\305\306\314D\"\210\315\324!\325	\326#BI\210\266\304!\n>\204\250\305\306\314D\"\210
\313H\316
@A
\203\272
\317\232\203\303\320\327\322\211\262\"\262\323
!\203\350\304!\n>\204\332\305\306\314D\"\210\313\324!\325	\326#BI\210\266\330\316\304!\n>\204\374\305\306\314D\"\210\331H\211\203G
\211@\211@
A
\203

\317\232\203
\320\332T\211\262\"\262\323
!\2038
\324!\325	\326#BB\262\266\202@
B\262\266
A\266\202\202\377\210\304!\n>\204X
\305\306\314D\"\210\331I\266\304!\n>\204m
\305\306\314D\"\210
\333HG\316U\203\334
\304!\n>\204\205
\305\306\314D\"\210
\333\334\335\304\211!\n>\204\233
\305\306\314	D\"\210\315HA!>\204\302
\305\306\336\304	!\n>\204\272
\305\306\314D\"\210\315HAD\"\210\304!\n>\204\323
\305\306\314D\"\210\315HA\333H\"I\210\304!\n>\204\353
\305\306\314D\"\210
\333\334\337\304!\n>\204\305\306\314D\"\210\333H\"I\207" [cl-struct-soap-element-tags cl-struct-soap-wsdl-tags cl-struct-soap-operation-tags cl-struct-soap-message-tags type-of signal wrong-type-argument soap-element 2 rassoc soap-wsdl 5 soap-operation 4 0 "" format "in%d" 1 soap-name-p intern soap-wsdl-get soap-message-p "out%d" nil 6 "fault%d" 3 mapcar car soap-message #[257 "\211;\203	\300
!\207\207" [intern] 3 "\n\n(fn P)"]] 13 (#$ . 194559)])
#@153 Resolve references for a BINDING type using the WSDL document.
See also `soap-resolve-references' and
`soap-wsdl-resolve-references'

(fn BINDING WSDL)
(defalias 'soap-resolve-references-for-binding #[514 "\302\303!>\204\304\305\306D\"\210\307H!\203A\303!>\204&\304\305\306D\"\210
\307\310\303!>\2049\304\305\306D\"\210\307H\311#I\210\303\211!>\204Q\304\305\306D\"\210\307H!	>\204s\304\305\312\303!>\204m\304\305\306D\"\210\307HD\"\210\303!>\204\202\304\305\306D\"\210
\307H\307H\313\314\315#\303!>\204\235\304\305\306D\"\210\316H\"\207" [cl-struct-soap-binding-tags cl-struct-soap-port-type-tags soap-name-p type-of signal wrong-type-argument soap-binding 3 soap-wsdl-get soap-port-type-p soap-port-type maphash make-closure #[514 "\303
!\n>\204\304\305\306D\"\210\211\307\310\301\311#I\210\312\303!\n>\204(\304\305\306D\"\210
\313H\211\203J\211@\314
@\300\"\315A@!\3168EB\262
A\266\202\202+\210\303!\n>\204Z\304\305\306D\"\210
\313\237I\207" [V0 V1 cl-struct-soap-bound-operation-tags type-of signal wrong-type-argument soap-bound-operation 1 soap-namespace-get soap-operation-p nil 3 soap-wsdl-get intern 2] 9 "\n\n(fn K V)"] 4] 9 (#$ . 196382)])
#@225 Replace names in PORT with the referenced objects in the WSDL.
This is a generic function, called by `soap-resolve-references',
you should use that function instead.

See also `soap-wsdl-resolve-references'.

(fn PORT WSDL)
(defalias 'soap-resolve-references-for-port #[514 "\301\302!>\204\303\304\305D\"\210\306H!\205@\302!>\204&\303\304\305D\"\210
\306\307\302!>\2049\303\304\305D\"\210\306H\310#I\207" [cl-struct-soap-port-tags soap-name-p type-of signal wrong-type-argument soap-port 4 soap-wsdl-get soap-binding-p] 9 (#$ . 197598)])
(byte-code "\300\301\302\303\304\211\211$!\305\306#\210\300\301\302\307\304\211\211\211\211\211\211\211&	!\305\310#\210\300\301\311 !\305\312#\210\300\301\302\313\304\211\211\211%!\305\314#\207" [put soap-type-of record soap-message nil soap-resolve-references soap-resolve-references-for-message soap-operation soap-resolve-references-for-operation make-soap-binding soap-resolve-references-for-binding soap-port soap-resolve-references-for-port] 12)
#@532 Resolve all references inside the WSDL structure.

When the WSDL elements are created from the XML document, they
refer to each other by name.  For example, the ELEMENT-TYPE slot
of an SOAP-ARRAY-TYPE will contain the name of the element and
the user would have to call `soap-wsdl-get' to obtain the actual
element.

After the entire document is loaded, we resolve all these
references to the actual elements they refer to so that at
runtime, we don't have to call `soap-wsdl-get' each time we
traverse an element tree.

(fn WSDL)
(defalias 'soap-wsdl-resolve-references #[257 "\302C\302\303!>\204\304\305\306D\"\210\307H\303!>\204%\304\305\306D\"\210\310H\211\203\245\211@\311\303!	>\204>\304\305\312D\"\210
\313H\"\242\211\204\200\3142\315\316T\211\262\"\262
\317
\"\204L\320
\303!	>\204p\304\305\312D\"\210\313H	#\210\321\314\322\"\210\202L\210\323\324\325		#\303!	>\204\230\304\305\312D\"\210\326H\"\266
A\266\202\202(\266\207" [cl-struct-soap-wsdl-tags cl-struct-soap-namespace-tags 0 type-of signal wrong-type-argument soap-wsdl 5 6 rassoc soap-namespace 1 done format "ns%d" assoc soap-wsdl-add-alias throw t maphash make-closure #[514 "\303
!\n>\203\301\211\242T\240\210\304
\300\"\207\211<\205;\211\211\2059\211@\303
!\n>\2032\301\211\242T\240\210\304
\300\"\210
A\266\202\202\262
\207" [V0 V1 cl-struct-soap-element-tags type-of soap-resolve-references] 7 "\n\n(fn NAME ELEMENT)"] 2] 13 (#$ . 198613)])
#@63 Error-check and parse the XML contents of the current buffer.
(defalias 'soap-parse-server-response #[0 "\300\301\211\"\211\211@;\203\211@\262
\202\211A@@\262
\302\232\203u\303\304\305\211@;\203.\211@\262
\2024\211A@@\262
#\306\232\203u\303\304\307\211@;\203K\211@\262
\202Q\211A@@\262
#\303\304\305\211@;\203c\211@\262
\202i\211A@@\262
#C\310\211\211\211\211\211\257\262
\211\204}\311\312!\210\211A@@\306\232\204\212\311\313!\210\314\315\301\"r\211q\210\316\317\"\216\320!\210\321ed\"@\322 \210\323!\210*\207" [mm-dissect-buffer t "multipart/related" get-text-property 0 type "text/xml" buffer nil error "Failed to decode response from server" "Server response is not an XML document" generate-new-buffer " *temp*" make-closure #[0 "\301\300!\205	\302\300!\207" [V0 buffer-name kill-buffer] 2] mm-insert-part xml-parse-region kill-buffer mm-destroy-part] 9 (#$ . 200081)])
#@106 Load an XML document from URL and return it.
The previously parsed URL is read from WSDL.

(fn URL WSDL)
(defalias 'soap-fetch-xml-from-url #[514 "\306\307\"\210\310\311!>\204\312\313\314D\"\210\315H\"\316\317\320\321\322\311!>\2043\312\313\314D\"\210
\315I\210\323
!r\211q\210\324V\203L\325\326\"\210\327 )\262
-\207" [cl-struct-soap-wsdl-tags url-http-attempt-keepalives url-mime-charset-string url-package-version url-package-name url-request-method message "Fetching from %s" url-expand-file-name type-of signal wrong-type-argument soap-wsdl 2 "GET" "soap-client.el" "1.0" "utf-8;q=1, iso-8859-1;q=0.5" t url-retrieve-synchronously 299 error "Error retrieving WSDL: %s" soap-parse-server-response url-http-response-status] 8 (#$ . 200984)])
#@109 Load an XML document from FILE and return it.
The previously parsed file is read from WSDL.

(fn FILE WSDL)
(defalias 'soap-fetch-xml-from-file #[514 "\302
!>\204\303\304\305D\"\210\211\306H\307\203\310!\202	\"\302!>\204/\303\304\305D\"\210\306I\210\311\312\313\"r\211q\210\314\315\"\216\316!\210\317ed\"@*\207" [cl-struct-soap-wsdl-tags default-directory type-of signal wrong-type-argument soap-wsdl 2 expand-file-name file-name-directory generate-new-buffer " *temp*" t make-closure #[0 "\301\300!\205	\302\300!\207" [V0 buffer-name kill-buffer] 2] insert-file-contents xml-parse-region] 8 (#$ . 201759)])
#@130 Load an XML document from FILE-OR-URL and return it.
The previously parsed file or URL is read from WSDL.

(fn FILE-OR-URL WSDL)
(defalias 'soap-fetch-xml #[514 "\301
!>\204\302\303\304D\"\210\211\305H\206
\211\203 \306
!\204&\306!\203+\307\"\207\310\"\207" [cl-struct-soap-wsdl-tags type-of signal wrong-type-argument soap-wsdl 2 file-exists-p soap-fetch-xml-from-file soap-fetch-xml-from-url] 6 (#$ . 202394)])
#@115 Load a document from FILE-OR-URL and return it.
Build on WSDL if it is provided.

(fn FILE-OR-URL &optional WSDL)
(defalias 'soap-load-wsdl #[513 "\211\206\300!\301\"\302\303\"!\210
\207" [soap-make-wsdl soap-fetch-xml soap-wsdl-resolve-references soap-parse-wsdl] 8 (#$ . 202828)])
(defalias 'soap-load-wsdl-from-url 'soap-load-wsdl)
#@39 Assert that NODE is valid.

(fn NODE)
(defalias 'soap-parse-wsdl-phase-validate-node #[257 "\303
\"\211@\206\n	
A@\206\n\3048\305\211@\262
!\211\306=\204,\307\310\311\312C$\210\312\262
+\207" [soap-local-xmlns soap-default-xmlns soap-target-xmlns soap-extract-xmlns 2 soap-l2wk wsdl:definitions cl--assertion-failed (eq node-name 'wsdl:definitions) "expecting wsdl:definitions node, got %s" nil] 8 (#$ . 203176)])
#@66 Fetch and load files imported by NODE into WSDL.

(fn NODE WSDL)
(defalias 'soap-parse-wsdl-phase-fetch-imports #[514 "\303\"\211@\206\n	
A@\206\n\3048\305\306\"\211\2057\211@\307
\310\"\211\203/\311
\"\210\210
A\266\202\202\262
+\207" [soap-local-xmlns soap-default-xmlns soap-target-xmlns soap-extract-xmlns 2 soap-xml-get-children1 wsdl:import xml-get-attribute-or-nil location soap-load-wsdl] 9 (#$ . 203607)])
#@53 Load types found in NODE into WSDL.

(fn NODE WSDL)
(defalias 'soap-parse-wsdl-phase-parse-schema #[514 "\303\"\211@\206\n	
A@\206\n\3048\305\306\"@\211\211AA\262
\211\205c\211@\211:\203\\\303
\"\211@\2067	
A@\206>\n\3048\307\211@\262
!\310=\203Z\311\312\"\"\210+\210
A\266\202\202\"\262
\262
+\207" [soap-local-xmlns soap-default-xmlns soap-target-xmlns soap-extract-xmlns 2 soap-xml-get-children1 wsdl:types soap-l2wk xsd:schema soap-wsdl-add-namespace soap-parse-schema] 11 (#$ . 204044)])
#@74 Fetch and load schema imports defined by NODE into WSDL.

(fn NODE WSDL)
(defalias 'soap-parse-wsdl-phase-fetch-schema #[514 "\304\"\211@\206\n	
A@\206\n\3058\306!>\204&\307\310\311D\"\210
\312H\205Y\306!>\204;\307\310\311D\"\210
\312H\211\312AI\210\262
\242\313
\"\314\315\"\"\266\202+\207" [soap-local-xmlns soap-default-xmlns soap-target-xmlns cl-struct-soap-wsdl-tags soap-extract-xmlns 2 type-of signal wrong-type-argument soap-wsdl 3 soap-fetch-xml soap-wsdl-add-namespace soap-parse-schema] 9 (#$ . 204570)])
#@48 Finish parsing NODE into WSDL.

(fn NODE WSDL)
(defalias 'soap-parse-wsdl-phase-finish-parsing #[514 "\305\"\211@\206\n	
A@\206\n\3068\307\310\311!\"\312\313\"\211\2035\211@\314\315!\"\210
A\266\202\202!\210\312\316\"\211\203g\211@\317
!\314
\"\210\320\321!>\204X\322\323\324D\"\210
\325H\"\266
A\266\202\202:\210\312\326\"\211\203\200\211@\314\327!\"\210
A\266\202\202l\210\312\330\"\211\203
\211@\312
\331\"\211\203\370\211@\211\332\333\"\206\237\334\266\202
\335\333\"\206\253\334\266\202\312\336\"@\211\337\333\"\206\274\334\266\202\262
\340\310\341\342\343\"\344&\314
\n\"\210\321!\f>\204\345\322\323\345
D\"\210\n\346
\346HBI\266
A\266\202\202\217\210
A\266\202\202\205\210\320
\"\262
+\207" [soap-local-xmlns soap-default-xmlns soap-target-xmlns cl-struct-soap-port-type-tags cl-struct-soap-wsdl-tags soap-extract-xmlns 2 make-soap-namespace :name soap-get-target-namespace soap-xml-get-children1 wsdl:message soap-namespace-put soap-parse-message wsdl:portType soap-parse-port-type soap-wsdl-add-namespace type-of signal wrong-type-argument soap-port-type 3 wsdl:binding soap-parse-binding wsdl:service wsdl:port name xml-get-attribute-or-nil "" binding wsdlsoap:address location make-soap-port :binding soap-l2fq tns :service-url soap-wsdl 4] 18 (#$ . 205120)])
#@81 Construct from NODE a WSDL structure, which is an XML document.

(fn NODE WSDL)
(defalias 'soap-parse-wsdl #[514 "\300!\210\301\"\210\302\"\210\303\"\210\304\"\210\207" [soap-parse-wsdl-phase-validate-node soap-parse-wsdl-phase-fetch-imports soap-parse-wsdl-phase-parse-schema soap-parse-wsdl-phase-fetch-schema soap-parse-wsdl-phase-finish-parsing] 5 (#$ . 206459)])
#@76 Parse NODE as a wsdl:message and return the corresponding type.

(fn NODE)
(defalias 'soap-parse-message #[257 "\301
\211@\262
!\302=\204\303\304\305\306\301\211@\262
!C$\210\307
\310\"\306\311\312\"\211\203n\211@\307
\310\"\307\313\"\307\314\"
\203?\315\316\"\262\211\203L\315
\316\"\262
\202]\317\320\306\306\211\211\211\211\211&\262

BB\262\266
A\266\202\202#\210\321\322\323\237$\207" [soap-target-xmlns soap-l2wk wsdl:message cl--assertion-failed (eq (soap-l2wk (xml-node-name node)) 'wsdl:message) "expecting wsdl:message node, got %s" nil xml-get-attribute-or-nil name soap-xml-get-children1 wsdl:part type element soap-l2fq tns record soap-xs-element make-soap-message :name :parts] 20 (#$ . 206842)])
#@77 Parse NODE as a wsdl:portType and return the corresponding port.

(fn NODE)
(defalias 'soap-parse-port-type #[257 "\303
\211@\262
!\304=\204\305\306\307\310\303\211@\262
!C$\210\311
\312\313\"\206%\314\266\202P\315\316\"\317\320\"\211\203
\211@\321
!\322\323!	>\204J\324\325\326D\"\210
\327H\330#\211\203v\331\323!	>\204d\324\325\326D\"\210\327HC\332\333\334\335#\336#\266\202
\337\"\210\323!\n>\204\213\324\325\340D\"\210
\341H\211\203\233\211
A\262\242\202\242\324\342\343GD\"\344
	#\266\323!\n>\204\271\324\325\340D\"\210
\345H\211\203\311\211
A\262\242\202\320\324\342\346GD\"\344
	#\266\323!\n>\204\347\324\325\340D\"\210
\347H\211\203
\211@\211
\203\376
\211A\262\242\202
\324\342\350GD\"\344
#\266
A\266\202\202\352\266
A\266\202\2021\210\351\316\312\313\"\206*
\314\266\202\352$)\207" [soap-target-xmlns cl-struct-soap-element-tags cl-struct-soap-operation-tags soap-l2wk wsdl:portType cl--assertion-failed (eq (soap-l2wk (xml-node-name node)) 'wsdl:portType) "expecting wsdl:portType node got %s" nil "urn:" name xml-get-attribute-or-nil "" make-soap-namespace :name soap-xml-get-children1 wsdl:operation soap-parse-operation soap-namespace-get type-of signal wrong-type-argument soap-element 1 soap-operation-p "Discarding duplicate operation: %s" display-warning soap-client apply format :warning soap-namespace-put soap-operation 4 wrong-number-of-arguments (name . message) soap-namespace-put-link 5 (name . message) 6 (name . message) make-soap-port-type :operations] 14 (#$ . 207583)])
#@78 Parse NODE as a wsdl:operation and return the corresponding type.

(fn NODE)
(defalias 'soap-parse-operation #[257 "\301
\211@\262
!\302=\204\303\304\305\306\301\211@\262
!C$\210\211\307\310\"\206$\311\266\202\312\313\310\"\2061\311\266\202!\306\211\211\211\211\211AA\262
\211\203\337\211@\211:\203\330\301
\211@\262
!\211\314\267\210\202\330
\315\310\"\206c\311\266\202\307\310\"\206o\311\266\202\316\317\"
\320\321\"B\262\262\266\202\330
\315\310\"\206\216\311\266\202\307\310\"\206\232\311\266\202\316\317\"
\320\321\"B\262\n\262\266\202\330
\315\310\"\206\271\311\266\202\307\310\"\206\305\311\266\202\211\320\321\"BB\262\266\202\330\210
A\266\202\202@\210\322\323\324\325\326\f\327
\330\237\331\332&\207" [soap-target-xmlns soap-l2wk wsdl:operation cl--assertion-failed (eq (soap-l2wk (xml-node-name node)) 'wsdl:operation) "expecting wsdl:operation node, got %s" nil name xml-get-attribute-or-nil "" split-string parameterOrder #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (wsdl:input 89 wsdl:output 132 wsdl:fault 175)) message soap-xml-get-attribute-or-nil1 wsaw:Action soap-l2fq tns make-soap-operation :name :namespace-tag :parameter-order :input :output :faults :input-action :output-action] 25 (#$ . 209155)])
#@76 Parse NODE as a wsdl:binding and return the corresponding type.

(fn NODE)
(defalias 'soap-parse-binding #[257 "\301
\211@\262
!\302=\204\303\304\305\306\301\211@\262
!C$\210\211\307\310\"\206$\311\266\202
\312\310\"\2060\311\266\202\313\314\315\316\317\"$\320\321\"\211\203C
\211@\211\307\310\"\206O\311\266\202\306\211\211\211\320\322\"\211\203m\211@\310
\323\"\262
A\266\202\202Z\210\320\324\"\211\203\324\211@\320
\325\"\211\203\253\211@\316\310\326\"!\310\327\"\310\330\"\203\242
\203\242E\nB\262\n\266
A\266\202\202}\210\320
\331\"@\310
\332\"\262\203\306\333\334\335\306\336#\"\262\310
\330\"\262\210
A\266\202\202s\210\211\204
\320\337\"\211\203
\211@\320
\331\"\211\203\377\211@\206\366\310
\330\"\262
A\266\202\202\350\210
A\266\202\202\336\210\340\341\342\343	\344\n\237\345\346\f\205\"
\334
!&\n\347!>\2045
\350\351\352
D\"\210\n\353H#\266
A\266\202\202?\210\207" [cl-struct-soap-binding-tags soap-l2wk wsdl:binding cl--assertion-failed (eq (soap-l2wk (xml-node-name node)) 'wsdl:binding) "expecting wsdl:binding node, got %s" nil name xml-get-attribute-or-nil "" type make-soap-binding :name :port-type soap-l2fq tns soap-xml-get-children1 wsdl:operation wsdlsoap:operation soapAction wsdl:input wsdlsoap:header message part use wsdlsoap:body parts mapcar intern split-string omit-nulls wsdl:output puthash make-soap-bound-operation :operation :soap-action :soap-headers :soap-body :use type-of signal wrong-type-argument soap-binding 4] 25 (#$ . 210491)])
#@136 The list of multi-ref nodes in the current SOAP response.
This is a dynamically bound variable used during decoding the
SOAP response.
(defvar soap-multi-refs nil (#$ . 212038))
#@140 List of decoded multi-ref nodes in the current SOAP response.
This is a dynamically bound variable used during decoding the
SOAP response.
(defvar soap-decoded-multi-refs nil (#$ . 212223))
#@314 Use TYPE (an xsd type) to decode the contents of NODE.

NODE is an XML node, representing some SOAP encoded value or a
reference to another XML node (a multiRef).  This function will
resolve the multiRef reference, if any, than call a TYPE specific
decode function to perform the actual decoding.

(fn TYPE NODE)
(defalias 'soap-decode-type #[514 "\305
\306\"\211\203f\3072\340\310
\"A\211\203\311\307\"\210\210\312\313\"\204'\314\315\"\210\316\317\"	\211\203]\211@\211\320\305\"\206<\321\266\202
\232\203U\322\"
BB\311\307\"\266\210
A\266\202\202,\210\314\323\"\262
0\207\324\n\"\211@\206p
A@\206w\f\3258\326\327\"\330\232?\205\335<\203\303\3072\335\211\205\275\211@\331
!\332N\3331\251\211\"0\202\253\210\334\211\203\264\311\307\"\210\266
A\266\202\202\221\262
0\202\335\331!\332N\211\204\327\335\336\337\334\331	!C$\210\211\"\262
+\262
\207" [soap-decoded-multi-refs soap-multi-refs soap-local-xmlns soap-default-xmlns soap-target-xmlns xml-get-attribute-or-nil href done assoc throw string-match "^#\\(.*\\)$" error "Invalid multiRef: %s" match-string 1 id "" soap-decode-type "Cannot find href %s" soap-extract-xmlns 2 soap-xml-get-attribute-or-nil1 xsi:nil "true" soap-type-of soap-decoder (error) nil cl--assertion-failed decoder "no soap-decoder for %s type"] 11 (#$ . 212420)])
#@58 Decode NODE using type information inside it.

(fn NODE)
(defalias 'soap-decode-any-type #[257 "\301
\302\"\211\203
\303
!\262
\211\203$\304
\305#\211\203\306
\"\207\307\310\"\207
\211AA\262
\211G\311U\203:\211@;\203:\211@\207\312
\211\203_\211@\211;\204X\211\211@\262
\313!

BB\262\266
A\266\202\202<\210\211\237\207" [soap-current-wsdl soap-xml-get-attribute-or-nil1 xsi:type soap-l2fq soap-wsdl-get soap-xs-type-p soap-decode-type error "Node has unknown type: %s" 1 nil soap-decode-any-type] 10 (#$ . 213769)])
#@70 Decode NODE as an Array using type information inside it.

(fn NODE)
(defalias 'soap-decode-array #[257 "\301
\302\"\303\211AA\262
\303\203*\304\305\306#\262\307\310!\311#\262\204*\312\313\"\210
\211\203O\211@\211:\203H\203A\314\"\202D\315
!B\262
A\266\202\202+\210\211\237\207" [soap-current-wsdl soap-xml-get-attribute-or-nil1 soapenc:arrayType nil replace-regexp-in-string "\\[[0-9]+\\]\\'" "" soap-wsdl-get soap-l2fq soap-xs-type-p error "soap-decode-array: Node has unknown type: %s" soap-decode-type soap-decode-any-type] 10 (#$ . 214306)])
(byte-code "\300\301!\203\301\302\303\"\210\202\304\302\305\306#\210\304\302\307\303#\210\300\207" [fboundp define-error soap-error "SOAP error" put error-conditions (error soap-error) error-message] 4)
#@183 Parse the SOAP envelope in NODE and return the response.
OPERATION is the WSDL operation for which we expect the response,
WSDL is used to decode the NODE.

(fn NODE OPERATION WSDL)
(defalias 'soap-parse-envelope #[771 "\304\"\211@\206\n	
A@\206\n\3058\306\211@\262
!\307=\2042\310\311\312\313\306\211@\262
!C$\210\314\315\"\314\316\"@\314
\317\"@\211\203o\320
\321\"@\211\211AA\262
\242\262
\320\322\"@\211\211AA\262
\242\262
\320\323\"\324\325E\"\210\202d\210\326!>\204\200\324\327\330D\"\210\331H\332=\203\214\211\202\260\3332\260\211\211AA\262
\211\205\255\211@\211:\203\246\334\333\"\210
A\266\202\202\226\262
0\335
%\262
\266\202+\207" [soap-local-xmlns soap-default-xmlns soap-target-xmlns cl-struct-soap-bound-operation-tags soap-extract-xmlns 2 soap-l2wk soap:Envelope cl--assertion-failed (eq (soap-l2wk (xml-node-name node)) 'soap:Envelope) "expecting soap:Envelope node, got %s" nil soap-xml-get-children1 soap:Header soap:Body soap:Fault xml-get-children faultcode faultstring detail signal soap-error type-of wrong-type-argument soap-bound-operation 5 literal found throw soap-parse-response] 15 (#$ . 215089)])
#@489 Parse RESPONSE-NODE and return the result as a LISP value.
OPERATION is the WSDL operation for which we expect the response,
WSDL is used to decode the NODE.

SOAP-HEADERS is a list of the headers of the SOAP envelope or nil
if there are no headers.

SOAP-BODY is the body of the SOAP envelope (of which
RESPONSE-NODE is a sub-node).  It is used in case RESPONSE-NODE
reference multiRef parts which are external to RESPONSE-NODE.

(fn RESPONSE-NODE OPERATION WSDL SOAP-HEADERS SOAP-BODY)
(defalias 'soap-parse-response #[1285 "\306!	>\204\307\310\311D\"\210\312H\306!	>\204%\307\310\311D\"\210\313H\306!\n>\2047\307\310\314D\"\210
\313HA\315\"\211@\206F\f
A@\206M
\3168\317=\203\212\320	\211@\262
!\321
	\322#\211=\204\210\323\324\306!%>\204\202\307\310\325	D\"\210\312H#\210\266\326\327\330\"\326&'\306!(>\204\245\307\310\331D\"\210\332H\211\203\226
\211@\211@
A\326\333\267\202]
\327\"@\202^
\3342^
\306
!)>\204\331\307\310\335D\"\210\f\313H\336\306!%>\204\357\307\310\325D\"\210\316H\"A\211\306!%>\204
\307\310\325D\"\210\312HB\337\340\341\"\211AA\262
\"\211\205U
\211@\211:\203N
\315
\"\211@\206.
\f
A@\2065

\3168\320\211@\262
!\232\203L
\342\334\"\210+\210
A\266\202\202
\262
\266\2030\202^
\326\262
\211\204
\323\343\306\f!%>\204x
\307\310\325D\"\210\312H#\210\344\"\211\203\215
\211B\262\266
A\266\202\202\250\210*\211\262
+\262
)\207" [soap-current-wsdl cl-struct-soap-bound-operation-tags cl-struct-soap-operation-tags soap-local-xmlns soap-default-xmlns soap-target-xmlns type-of signal wrong-type-argument soap-bound-operation 1 5 soap-operation soap-extract-xmlns 2 encoded soap-l2fq soap-wsdl-get soap-message-p error "Unexpected message: got %s, expecting %s" soap-element nil xml-get-children multiRef soap-message 3 #s(hash-table size 2 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (encoded 186 literal 195)) found soap-wsdl assoc append mapcar #[257 "\211\211AA\262
@\207" [] 3 "\n\n(fn HEADER)"] throw "Soap-parse-response(%s): cannot find message part %s" soap-decode-type cl-struct-soap-element-tags soap-decoded-multi-refs soap-multi-refs cl-struct-soap-message-tags cl-struct-soap-wsdl-tags] 25 (#$ . 216265)])
#@272 Encode XML attributes for VALUE according to TYPE.
This is a generic function which determines the attribute encoder
for the type and calls that specialized function to do the work.

Attributes are inserted in the current buffer at the current
position.

(fn VALUE TYPE)
(defalias 'soap-encode-attributes #[514 "\300
!\301N\211\204\302\303\304\305\300!C$\210\211\"\207" [soap-type-of soap-attribute-encoder cl--assertion-failed attribute-encoder "no soap-attribute-encoder for %s type" nil] 9 (#$ . 218526)])
#@314 Encode the VALUE using TYPE.
The resulting XML data is inserted in the current buffer
at (point)/

TYPE is one of the soap-*-type structures which defines how VALUE
is to be encoded.  This is a generic function which finds an
encoder function based on TYPE and calls that encoder to do the
work.

(fn VALUE TYPE)
(defalias 'soap-encode-value #[514 "\302
!\303N\211\204\304\305\306\307\302!C$\210\211\"\266\310
!>\204)\311\312\313D\"\210\211\314H\205R\310
!>\204>\311\312\313D\"\210\211\314H\211	\235\203K	\202P\211	B\211\262
\207" [cl-struct-soap-element-tags soap-encoded-namespaces soap-type-of soap-encoder cl--assertion-failed encoder "no soap-encoder for %s type" nil type-of signal wrong-type-argument soap-element 2] 9 (#$ . 219048)])
#@323 Create the body of a SOAP request for OPERATION in the current buffer.
PARAMETERS is a list of parameters supplied to the OPERATION.

The OPERATION and PARAMETERS are encoded according to the WSDL
document.  SERVICE-URL should be provided when WS-Addressing is
being used.

(fn OPERATION PARAMETERS &optional SERVICE-URL)
(defalias 'soap-encode-body #[770 "\305!>\204\306\307\310D\"\210\311H\305!>\204\"\306\307\310D\"\210\312H\305!	>\2044\306\307\313D\"\210
\314HA\305!	>\204G\306\307\313D\"\210\315H\211\316\316\211:\203t@\262:\203t@\262B
B\262
A\262A\262\202P\211\237\266\205
GGU\204\237\317\320\305!\n>\204\224\306\307\321	D\"\210\311HG\nG$\210\305!>\204\260\306\307\310\nD\"\210\315H\305!	>\204\305\306\307\313D\"\210\322H
\203\201
\323c\210\211\203\357\324\235\203\336\210\202\342\324B\325
\326\261\210\327\330\261\210
\211\203}
\211@\211@
A@\305!\f>\204\n
\306\307\331D\"\210
\315H\236\332
@@\"A\3338A
\334=\203a
\305
!\n>\2040
\306\307\321D\"\210\211\333H\203Y
\305
!\n>\204E
\306\307\321D\"\210\211\333H\211\235\203T
\266\202Y
\211B\210\335\336!\337\261\210\340\"\210
\334=\203t
\341\336!\337\261\210\266
A\266\202\202\360\210\342c\210\266\343c\210\334=\203\317
\305!\n>\204\234
\306\307\321D\"\210\333H\203\306
\305!\n>\204\262
\306\307\321D\"\210\333H\211\235\203\301
\266\202\306
\211B\210\335\336!\337\261\210\305!\f>\204\336
\306\307\331D\"\210\315H\211\2031\211@\211@
A\332\"A\305
!>\204\306\307\310D\"\210\f\314H\203#\305!>\204\306\307\310D\"\210
\314H\235\203(\340
\"\210\266
A\266\202\202\341
\210\334=\203A\341\336!\337\261\210\344c\207" [cl-struct-soap-bound-operation-tags cl-struct-soap-operation-tags cl-struct-soap-element-tags soap-encoded-namespaces cl-struct-soap-message-tags type-of signal wrong-type-argument soap-bound-operation 1 5 soap-operation 4 3 nil error "Wrong number of parameters for %s: expected %d, got %s" soap-element 7 "<soap:Header>\n" "wsa" "<wsa:Action>" "</wsa:Action>\n" "<wsa:To>" "</wsa:To>\n" soap-message assoc 2 encoded "<" soap-element-fq-name ">\n" soap-encode-value "</" "</soap:Header>\n" "<soap:Body>\n" "</soap:Body>\n"] 21 (#$ . 219814)])
#@240 Create a SOAP request envelope for OPERATION using PARAMETERS.
WSDL is the wsdl document used to encode the PARAMETERS.
SERVICE-URL should be provided when WS-Addressing is being used.

(fn OPERATION PARAMETERS WSDL &optional SERVICE-URL)
(defalias 'soap-create-envelope #[1027 "\304\305\306\"r\211q\210\307\310\"\216\311\312!>\204\313\314\315D\"\210\316H
\317#\210eb\210\320c\210\211\321=\203<\322c\210	\211\203{\211@\323
\324\261\210\325
\n\"A\211\204m\325\312\n!>\204e\313\314\326\fD\"\210	\316H\"A\262
\211c\210\327c\266
A\266\202\202=\210\330c\210db\210\331c\210)\266\332 *\207" [cl-struct-soap-bound-operation-tags soap-encoded-namespaces soap-well-known-xmlns cl-struct-soap-wsdl-tags generate-new-buffer " *temp*" t make-closure #[0 "\301\300!\205	\302\300!\207" [V0 buffer-name kill-buffer] 2] ("xsi" "soap" "soapenc") type-of signal wrong-type-argument soap-bound-operation 5 soap-encode-body "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<soap:Envelope\n" encoded "    soapenc:encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\"\n" "    xmlns:" "=\"" assoc soap-wsdl "\"\n" ">\n" "</soap:Envelope>\n" buffer-string] 16 (#$ . 222065)])
(byte-code "\300\301\302\303\304DD\305\306\307%\207" [custom-declare-variable soap-debug funcall function #[0 "\300\207" [nil] 1 ""] "When t, enable some debugging facilities." :type boolean] 6)
#@92 Return the WSDL port having SERVICE name.
Signal an error if not found.

(fn WSDL SERVICE)
(defalias 'soap-find-port #[514 "\3022B\303!>\204\304\305\306D\"\210
\307H\211\205?\211@\303!	>\204,\304\305\310D\"\210
\311H\232\2038\312\302\"\210
A\266\202\202\262
0\206I\313\314\"\207" [cl-struct-soap-wsdl-tags cl-struct-soap-element-tags found type-of signal wrong-type-argument soap-wsdl 4 soap-element 1 throw error "Unknown SOAP service: %s"] 9 (#$ . 223449)])
#@111 Inside PORT, find OPERATION-NAME, a `soap-port-type'.
Signal an error if not found.

(fn PORT OPERATION-NAME)
(defalias 'soap-find-operation #[514 "\303!>\204\304\305\306D\"\210
\307H\310\303!	>\204#\304\305\311D\"\210\307H\"\211\206D\312\313\303!\n>\204?\304\305\314	D\"\210\315H#\207" [cl-struct-soap-port-tags cl-struct-soap-binding-tags cl-struct-soap-element-tags type-of signal wrong-type-argument soap-port 4 gethash soap-binding error "No operation %s for SOAP service %s" soap-element 1] 11 (#$ . 223933)])
#@176 Return the number of arguments required by a soap operation.
WSDL, SERVICE, OPERATION-NAME and PARAMETERS are as described in
`soap-invoke'.

(fn WSDL SERVICE OPERATION-NAME)
(defalias 'soap-operation-arity #[771 "\302\"\303
\"\304
!>\204\305\306\307D\"\210\211\310H\304
!	>\204)\305\306\311D\"\210\211\312HG\207" [cl-struct-soap-bound-operation-tags cl-struct-soap-operation-tags soap-find-port soap-find-operation type-of signal wrong-type-argument soap-bound-operation 1 soap-operation 3] 10 (#$ . 224474)])
#@391 Implement `soap-invoke' and `soap-invoke-async'.
If CALLBACK is non-nil, operate asynchronously, then call CALLBACK as (apply
CALLBACK RESPONSE CBARGS), where RESPONSE is the SOAP invocation result.
If CALLBACK is nil, operate synchronously.  WSDL, SERVICE,
OPERATION-NAME and PARAMETERS are as described in `soap-invoke'.

(fn CALLBACK CBARGS WSDL SERVICE OPERATION-NAME &rest PARAMETERS)
(defalias 'soap-invoke-internal #[1413 "\306\"\307
\"\310\311\312\313\314\f\315\n!>\204#\316\317\320\fD\"\210	\321H$\322\"\323\324\325\326\313\315\n!	>\204@\316\317\327\fD\"\210	\330H\322\"\326QB\331\332BD*+,\203~\333\315!>\204l\316\317\320D\"\210\321H\334\335%\"\202\344\336\315!>\204\216\316\317\320D\"\210\321H!\3371\322\3401\306r\211q\210-\204\247\341\342!\210.\203\271-\343V\203\271\344\345-\"\210\346\347 	#)00\202\3420\316
@A\"\262
\202\342.\203\333\350!\210\341\351!!\262
\262
.\207" [cl-struct-soap-port-tags cl-struct-soap-bound-operation-tags url-request-extra-headers url-http-attempt-keepalives url-mime-charset-string url-request-data soap-find-port soap-find-operation "POST" "soap-client.el" "1.0" encode-coding-string soap-create-envelope type-of signal wrong-type-argument soap-port 3 utf-8 "utf-8;q=1, iso-8859-1;q=0.5" t "SOAPAction" "\"" soap-bound-operation 2 "Content-Type" "text/xml; charset=utf-8" url-retrieve make-closure #[257 "p\304\305\"\216\306\307\"\211\203\310
@A\"\202!\311\300\312\313 \303\302#\301#\262
)\207" [V0 V1 V2 V3 make-closure #[0 "\301\300!\205	\302\300!\207" [V0 buffer-live-p kill-buffer] 2] plist-get :error signal apply soap-parse-envelope soap-parse-server-response] 9 "\n\n(fn STATUS)"] url-retrieve-synchronously (error) (soap-error) error "No HTTP response from server" 299 warn "Error in SOAP response: HTTP code %s" soap-parse-envelope soap-parse-server-response pop-to-buffer error-message-string url-package-version url-package-name url-request-method url-http-response-status soap-debug] 21 (#$ . 225001)])
#@790 Invoke a SOAP operation and return the result.

WSDL is used for encoding the request and decoding the response.
It also contains information about the WEB server address that
will service the request.

SERVICE is the SOAP service to invoke.

OPERATION-NAME is the operation to invoke.

PARAMETERS -- the remaining parameters are used as parameters for
the SOAP request.

NOTE: The SOAP service provider should document the available
operations and their parameters for the service.  You can also
use the `soap-inspect' function to browse the available
operations in a WSDL document.

NOTE: `soap-invoke' base64-decodes xsd:base64Binary return values
into unibyte strings; these byte-strings require further
interpretation by the caller.

(fn WSDL SERVICE OPERATION-NAME &rest PARAMETERS)
(defalias 'soap-invoke #[899 "\300\301\302\211&\207" [apply soap-invoke-internal nil] 12 (#$ . 227035)])
#@319 Like `soap-invoke', but call CALLBACK asynchronously with response.
CALLBACK is called as (apply CALLBACK RESPONSE CBARGS), where
RESPONSE is the SOAP invocation result.  WSDL, SERVICE,
OPERATION-NAME and PARAMETERS are as described in `soap-invoke'.

(fn CALLBACK CBARGS WSDL SERVICE OPERATION-NAME &rest PARAMETERS)
(defalias 'soap-invoke-async #[1413 "\204\300\301!\210\302\303&\207" [error "Callback argument is nil" apply soap-invoke-internal] 14 (#$ . 227945)])
(provide 'soap-client)